Three Days: How an Open-Source Rival to Jev Ended Up Running on Your Laptop

The short answer

On 15 September 2026, TypeSafe AI launched Jev, a hosted model that doesn't write text. It returns a typed decision (a choice, a score, a yes/no with a probability) in roughly 70–500 ms, sold per token over an API.

On 18 September, three days later, Convai Innovations released Laya: a model built for the same job, with open weights under Apache 2.0, free, and able to run on your own hardware. A few days after that, a community port called laya-mlx had it answering questions in 13.42 ms on a MacBook, using under 1 GB of memory, with no cloud call at all.

The popular headline says someone open-sourced Jev. That isn't quite what happened, and the real story is more interesting. Jev is still closed. What got open-sourced is the idea, and it took 72 hours.

Wait, a model that doesn't write?

Most of what an AI agent does all day isn't writing. It's deciding:

• Is this email urgent?
• Which of these 12 tools should handle this request?
• Is this message spam, a support ticket or a sales lead?
• Should this action wait for a human to approve it?

Today most agents send every one of those questions to a large language model. The model spends hundreds of milliseconds and real money producing a paragraph, and then your code tries to pull a single word out of it. It's like hiring a novelist to tick a checkbox.

TypeSafe calls the alternative a "System One" model, borrowing Kahneman's fast, intuitive System 1 as opposed to the slow, deliberate System 2. You ask a typed question and get a typed answer back, with a calibrated confidence score, in one forward pass. There's no generation, so there's no rambling, and it never returns malformed JSON.

That's the category. Jev defined it commercially (we explain Jev itself in more depth in Jev isn't an LLM). Laya showed it doesn't need to stay behind an API.

Jev vs Laya vs laya-mlx, side by side

These are three different things that keep getting blurred together:

	Jev	Laya	laya-mlx
What it is	Hosted decision model	Open-weight decision model	Apple Silicon runtime for Laya
Made by	TypeSafe AI	Convai Innovations	Community (mizorewww)
Released	15 Sep 2026	18 Sep 2026	Shortly after Laya
Open source?	No, API only	Yes, Apache 2.0	Yes, Apache 2.0
Runs locally?	No	Yes (GPU recommended)	Yes, on M-series Macs
Cost	Paid per token	Free	Free
Size	Not disclosed	322M–421M parameters	Same Laya checkpoints
Speed (vendor-reported)	~70–500 ms	~33 ms on a Tesla T4	13.42 ms median on an M3 Max

Look at the size row for a moment. Laya's checkpoints are built on BERT-family encoders with 421 million parameters. That's about 1/170th the size of a 70B model, and small enough that laya-mlx reports a footprint of 943.6 MiB for the English model and 687.6 MiB for the multilingual one. A Chrome tab can use more memory than that.

Getting it running takes one line:

pip install laya-mlx

There's also a Node.js / TypeScript port built on ONNX Runtime, so JavaScript developers aren't left out.

Why this is moving so fast

A paid product defined a new category, and a free, local alternative arrived three days later. That gap used to be measured in years. Then it shrank to months. For "System One" models, it was one long weekend.

A few things made that possible:

1. The idea was easy to copy even though the model wasn't. Once Jev showed that typed decisions beat generated text for classification-shaped work, the recipe was clear: take a strong pretrained encoder, train it to score typed options, and calibrate the probabilities. None of that needed a frontier lab.
2. Encoders are cheap. A 400M-parameter encoder can be trained and served on hardware a small team can afford. The barrier to entry was never compute. It was knowing what to build.
3. The open ecosystem ports things within days. MLX for Macs, ONNX for Node, Hugging Face for distribution. Once weights are public, "runs on my laptop" is just the next pull request.

The part the hype skips

Honest numbers matter more than excited ones, especially when you're picking something to build on. The independent write-up from Flowtivity is the one to read, and it deflates a few headlines:

• Laya's top result is from a fine-tuned model. Laya's 0.766 accuracy on the typed-decisions benchmark (vs Jev's 0.727) comes from a checkpoint fine-tuned on that benchmark's own training split. Zero-shot, the base model scores 0.362, which is below the 0.461 majority-class baseline. Laya's own model card says it plainly: it is "a fast base to specialise, not a zero-shot decision engine."
• Jev wins when there are many options. On Banking77, a 77-label intent task, Flowtivity reports Jev at 0.870 and Laya at 0.425. If your question has dozens of possible answers, the hosted model is much stronger today.
• "Runs on your PC" comes with conditions. laya-mlx is Apple Silicon only (macOS 14+, Python 3.11+). On Windows or Linux you'd run the base Laya package, ideally with a GPU.
• Neither one writes. Both are useless for drafting, summarising or chatting. They sit next to an LLM. They don't replace it.

The accurate version of the story is this: Laya is a free, fast, local base you fine-tune on your own decisions. Jev is a paid, broader model you call and it just works. Both are real options, and which one fits depends on your situation, not on which is newer.

What this means if you build agents

The bigger shift here isn't one model beating another. It's a change in how agents are built.

Until now, an agent had one brain, and every question went to the big, slow, expensive model. The emerging design has two tiers:

• A System One tier that's tiny, local and runs in milliseconds. It handles the hundreds of routing, triage and "is this safe?" questions an agent asks every minute.
• A System Two tier, a full LLM (local or cloud), for work that actually needs reasoning or writing.

Latency is only part of the gain. When the fast tier runs on your machine, the routine questions about your inbox, screen and files never leave the device. That's the same argument we made about local-first privacy and local vs cloud model routing. It now extends to decisions as well as generation.

It also changes what's possible for human-in-the-loop safety. A calibrated probability is exactly what you need for a rule like "act automatically above 0.9 confidence, ask a human below it." With a text-generating LLM, you have to ask the model how confident it is and hope the answer means something. A System One model gives you a number designed to be meaningful.

For an agent that runs all day in the background, like the multi-agent mesh Vyra is built around, this is the direction to watch. The question for any resident assistant is no longer only "which LLM?" It's also "which decisions should never need an LLM at all?"

Common questions about Laya and Jev

Did someone open-source Jev?

No. Jev is still a closed, hosted model from TypeSafe AI that you reach through an API. Some tooling around it is open source, but the model isn't. Laya is a separate model from a different company (Convai Innovations), released three days later as an open-weight alternative for the same kind of typed-decision work.

Is Laya an LLM?

Not in the usual sense. It's an encoder-based model that scores options for typed questions (choice, score, true/false) in a single forward pass. It never generates text, which is why it's so fast and why it can't replace a chat model.

Can I run Laya on my own computer for free?

Yes. The weights are Apache 2.0. On an Apple Silicon Mac, pip install laya-mlx runs it natively, and the project reports a 13.42 ms median latency on an M3 Max. On Windows or Linux, use the upstream laya package, preferably with a GPU. Plan to fine-tune it on your own labelled decisions, because zero-shot accuracy is weak.

Is Laya better than Jev?

It depends on the task. Laya is faster, free and local, and it beats Jev on some benchmarks once fine-tuned. Jev is much stronger zero-shot and on questions with many possible answers, such as Banking77 (0.870 vs 0.425 in independent testing). If you have labelled data and want control, try Laya. If you want broad coverage with no setup, Jev is the easier choice.

What would I actually use a decision model for?

For the high-volume yes/no and pick-one questions in any workflow: support triage, spam and moderation, lead scoring, intent routing, choosing which tool an agent calls, and deciding whether an action needs human approval. Anything where you'd otherwise ask an LLM for one word and parse it out of a paragraph.

---

Vyra (vyraagi.com) is a resident desktop agent: a five-domain agent mesh of 15+ specialized agents that works in the background on your machine. Deciding when not to reach for a big model is one of the most important design choices an agent makes, and this week showed it's getting cheaper. Join the waitlist to follow what we build next.