Laya, specified
The long version: the three checkpoints and what each one is for, the limits the model card admits to, and the four measurements we ran ourselves.
Kinds of workSix pages, one per kind of thing built on Laya — 54 of the 55 records we hold carry one of them.
Model reference · verified 2026-09-24
Laya is an open-weight decision model published by Convai Innovations on 18 September 2026, three days after TypeSafe's Jev. You hand it a piece of text and a set of typed questions, and one forward pass returns the answers with probabilities — no tokens, no prose to parse, no API bill. It is the first serious open implementation of the idea Jev is sold on.
Weights Apache-2.0, on Hugging Face The repository →
A Tetris build against a cloud model, local Laya winning by making decisions eleven times faster on a 16 GB MacBook Air. It is a game, so the result is about the loop rather than the model, and the post does not pretend otherwise.
The upstream model, and the row the rest of this column is built around: three checkpoints, a router that picks between them per request, and a server that answers TypeSafe's own POST /v1/systemone shape. Its benchmark table puts the publisher's own measurements next to Jev numbers it has never reproduced, and says so in the line above the table.
The most-watched explainer that names Laya in its own description rather than in a thumbnail: thirteen minutes of framing the System One idea before anything is run. Treat it as orientation — the channel compares open clones against each other, not against a fixed benchmark.
The thread that started the argument: the author posting a year-old, non-autoregressive decision model the week Jev became famous. 1,349 points and 316 comments, most of them about who gets credit rather than about the model — read it for the priority claim and the pushback together.
A thread that starts as a joke about a year-old project nobody noticed and turns into the sharpest take in the corpus: the difference was not marketing but that Jev framed the problem as a category. Worth reading for the argument about framing rather than for anything about the weights.
The port that made the numbers small: 13.4 ms median for a short English decision, 7.4 ms with the multilingual checkpoint, no PyTorch in the runtime. The README is unusually careful — it says in the caption that the latency figure is a one-question benchmark and not the frame time of the Snake loop in the GIF above it.
The video the snake-and-fighting arena came from, and it links the repository on the first line of its description, which is rare enough to be worth the card. The comparison is a game, so what it measures is the whole loop: model, prompt and safety checks together.
174 points on running Laya's smallest checkpoint on a Mac through Core ML, including the memory figure people keep quoting. The comments are more useful than the headline: several of them are people working out how far the 0.74 GB claim travels.
A patient explainer for readers who have heard the name and cannot say what it does: how a decision model differs from a chat model, why the output has no prose to parse, and what that changes about cost. Posted by someone with no stake in either project, which is why it is near the top of this wall.
The same author's Core ML port, and the rare demo that reports energy instead of speed: 2.78× better whole-system energy per decision than compiled MLX at 4.98 ms p50. The benchmark document also says which measurements exclude terminal rendering and which do not, which is the detail that decides whether a number means anything.
A nine-minute walkthrough aimed at people who have heard the name and not the mechanism: one forward pass, three question types, no generated text, Apache-2.0 weights. The channel's framing is enthusiastic; the parts worth keeping are the three primitives and the licence.
A first-person write-up of moving typed decisions onto a Mac Studio for privacy rather than for speed, with the gateway design and the fail-closed rules spelled out. Rare in this genre: the author says plainly that he did not test whether Laya beats Jev overall, which is why we quote his deployment rather than his opinion.
A Chinese-language roundup of the five open models that appeared within days of Jev, with Laya at the top of the list. It is useful as a map of the week rather than as an evaluation: five names, one line each, no measurements.
The Node path: ONNX Runtime, no Python at runtime, and about 1.7 GB of fp32 weights cached on first call. The README claims the output matches the Python reference to four decimal places — which is exactly the kind of claim a reader should re-run on their own inputs before trusting it.
Local install plus three demos, which is the shape a reader actually needs: get the package, download the weights, then watch something work. The description points at the module names rather than at a benchmark, so it is a tutorial and we are calling it one.
A Show HN for a vision variant: images in, typed decisions out, no generated text. It is one of the first extensions of the idea past text, and the thread is short, so the card is a pointer rather than a debate.
The claim-heavy version: ten times faster on published numbers, multilingual, no per-token bill, and a latency comparison of 38 ms local against 400 ms remote. Every figure comes from a benchmark somebody else ran, and the post does not say which.
A 151M decision engine that claims to beat both Jev and Laya, with an in-browser WebGPU path so it can run without a server at all. It is the loudest set of numbers in this column and it comes with the least context, so the row is here as a claim to check rather than a result to quote.
Starts from a homely, real problem — a support-ticket classifier that costs money on every request — and runs the model on a local GPU instead. The audience is people deciding whether to keep paying an API bill, which is most of the audience for this model.
The Show HN behind the smallest-memory claim in this column, and the reason the MPS row above exists. Three points and no comments, which is worth stating: a thread's score tells you how many people noticed, not whether the thing works.
A benchmark run by someone with no stake, comparing Jev, a 4B open model and Laya on the same tasks — and then inferring that Jev is around 30B parameters from the gap. The inference is labelled as an inference, which is the part we trust.
A website, three games, a benchmark and an agent skill in one repository. The public site has no model behind it and replays recorded runs, which is a more honest arrangement than a demo that quietly falls back to an API — and the same pages drive the real model once you clone it.
Twenty-six minutes on the open model and what it does to a funded competitor's pricing story. Its title promises a verdict the video cannot fully deliver — the comparison numbers are the ones the model's own publisher published — so the card belongs in the argument about the model, not in the evidence for it.
Laya playing Tetris by itself, posted as a Show HN. Three points, no comments, and it is still on this wall because the game loop is the clearest demonstration of what a 30 ms decision actually buys you — and because the same demo is what most of the model's traffic arrived through.
The second post from the same account, and the more specific one: 7 to 14 ms per decision, under a gigabyte of memory, and a claim that a local assistant setup finished in a single pass. The memory ceiling is the number that decides whether this runs on the laptop you already own.
Browser Use's ultrafast agent with the decision call swapped for local Laya, and the README is scrupulous about the split: the agent, the DOM snapshot, the executor, the safety checks and the design are theirs, only the decisions changed hands. Median about 33 ms on an M1 Max, and no per-step API cost.
The one video here that deals with the dispute rather than the benchmark: who built what first, what the open model owes its predecessors, and why the argument got loud. The channel states its position openly, which makes it usable as a summary of the disagreement rather than as a ruling on it.
A distribution argument rather than a benchmark: the open weights going into a Linux distribution's hardware integration so that a decision model is always present, offline and unbilled. If the pattern holds, this is the shape it takes when it stops being news.
Two models, one Chrome dinosaur, and a replay of every crash. A deterministic planner labels the moves and the models choose between them, so the README says outright that an assisted score measures the whole system — the sentence most comparison demos leave out.
A free-alternative video with a paid community behind it, and we would rather say so on the card than let a reader find out halfway through. The technical content is a competent tour of the install; the discount framing in the description is the author's business model, not a fact about the model.
Someone who went looking for what happened a year ago and came back with a list of prior art — GLiClass and others already doing zero-shot classification — and an argument that Jev's contribution is the framing. Disagreement with it is easy to find in the same thread on Hacker News.
ggml underneath, with CUDA, Vulkan and Core ML backends, a Jev-compatible HTTP server and request batching. It is the first port here that treats Windows as a first-class target — signed binaries rather than a build script and a paragraph of apologies, which for a C++ inference engine is the hard part.
Six minutes, and the fastest of these videos to get to the point: the package, the weights, the three question types, done. Useful precisely because it does not try to argue the case for the model, which the longer videos above spend most of their time on.
A practitioner's post that refuses the comparison everyone else is making: the problem is not which model is better but how you define the decision space and batch the calls, and on that reading the local model and the hosted one came out tied in his own build.
Evals and guardrails where the judge is a decision model instead of an LLM, published by a company that already sells evals. The argument is arithmetic rather than vibes: all the evals for one trace go out as one request, for a few thousandths of a cent, which is what makes running them on every trace affordable.
A 'second brain for agents' explainer with the architecture animated, aimed at people building agent loops rather than at people choosing a model. The framing is promotional; the useful part is the split between deciding and explaining.
Prebuilt agents — browser, computer, robotics, games — with a decision model as the brain and a choice of Jev, Laya or Cua-S1 underneath. There is a video at the top of the README, which is the fastest way to see what the pattern is for if the prose has not landed yet.
The licence, the parameter count, the backbone and the per-query latency, in one screen — a rare post in this corpus that puts the Apache-2.0 line and the speed claim in the same paragraph, which is what a reader deciding whether to adopt it actually needs.
It starts a step earlier than the decision: turning "add caching to the user API" into a typed IntentSpec, probing for what it can look up and asking for what it cannot, then refusing to emit while the request is still underspecified. The halt is the part most routers leave out and the part that makes the output trustworthy.
An offer to host the open model for free, with the three question types spelled out and a thread promising the rest. Worth a card because self-hosting is the part most readers will not do, and somebody offering to do it for them is a real answer to that.
Docker-first, with a web interface, from a team that already ships server tooling. The part worth noticing is not the UI: it is that a project with release tags and a Chinese-language README has picked Laya up and packaged it as a service you start with one command.
The hype cut of the comparison, with the funding figure and the launch story attached: a $40M round, a former OpenAI researcher, and an open model going head to head with it days later. Its numbers come from the publisher's own benchmark table, which is worth holding in mind while watching.
A Rust server for the System One protocol: candle underneath, dynamic batching by token count, CPU, CUDA and Metal backends. The headline number comes with its hardware attached — about 14 ms per query on an RTX Pro 6000 — which is more than most rows in this column manage.
A first-person account of getting the MLX port working on Apple silicon and being impressed by what does not happen: no cloud call, no PyTorch, no tokens generated one at a time. Enthusiastic, and specific about the install, which is why it made the wall.
The arena from the Prompt Engineer 48 video: a snake race and a fighting game, every move a real decision, and a docker one-liner that lets a person take the place of one side. A fighting game is a more searching test than it looks — it needs a decision under time pressure where the opponent has already moved.
A Chinese-language description of the three question types that treats them as an API rather than as a novelty, which is the right level for this model. Short, technical, and it links the model card instead of a video.
Serve Laya or a head you trained yourself, on a GPU or a Mac, behind a Jev-compatible API. It arrives with a build log rather than a pitch — a Sunday-morning post about a cat and a local Jev — and the diagram spends its space on where the model sits next to an LLM instead of on benchmark bars.
The 33 ms number with the mechanism attached: bidirectional encoders, a calibrated probability instead of tokens, three primitives. A promotional account's summary, but it states the architecture correctly, which is more than most of the summaries here manage.
A local proxy that records the typed decisions your application already sends to an LLM, learns them, and answers later ones with a Laya head — so most calls never leave the machine. The interesting half is not the 90% claim, it is that the training data is your own traffic rather than a benchmark.
The dissent, kept on purpose: a reply arguing that the fast model is a research project next to the hosted one, with the comparison that one is a useful tool and the other is interesting. Two likes and no evidence, which is what it is — but a wall with no dissent on it is an advertisement.
PyTorch's Metal backend instead of MLX or Core ML, and the row that treats memory as the constraint rather than latency: about 2.1 GiB in the fast mode, and a slower 0.74 GiB mode for machines that cannot spare it. The Pong demo renders the response time on the frame, so the number in the README is visible while it runs.
A third-party Japanese model that claims to beat Laya's multilingual checkpoint on a 300-item benchmark built on an unseen schema — and adds an observation worth checking: that the checkpoint never chooses the first-listed score option, in either language.
The most useful post on this wall by a distance, because it is the one that reports a loss: the same author tested both models as a shell-command safety classifier and the faster one let 44 of 111 attacks through against six. Posted as a warning, and it reads like one.
A Chinese-language test write-up with a conclusion that cuts against the enthusiasm: on the same machine Jev covered more of the questions asked of it, though the post is careful to say the gap is about coverage rather than about speed, where the local model wins.
Every entry on this page is in one of the columns, with the full list and its filters: Built with Laya (18) · Seen on X (22) · Videos (9) · Threads (6)
The 6 kinds cover 54 of the 55 records in this topic; the rest are announcements and explainers, which belong to no kind and to no chip. A chip's number counts every record in the topic — the wall on this page is a sample of it, so switching a chip on shows the matching cards from these 54, and the complete list behind each kind is its own page, linked from Kinds of work.
An open-weight decision model: a state and a set of typed questions go in, and one forward pass returns typed answers with probabilities. It does not generate text, and it is the same three question types Jev uses — choice, score and noul. The English checkpoint is a 421M-parameter ModernBERT-large with a two-layer head, published under Apache-2.0.
Its server speaks TypeSafe's wire protocol, and a client written for Jev parses the responses — we pointed our own Jev probe at it and all thirteen adversarial cases came back as valid answers. The envelope carries extra fields a strict client would reject, and the answer to a non-Latin state comes from a different checkpoint than the one the request named.
Yes. On one CPU core set we measured a 1-question call at 0.30 s median, ten questions at 2.09 s and fifty at 10.4 s — about 0.21 s per question, flat. The weights download is roughly 1.2 GB including the encoder.
The model card's frontmatter says apache-2.0, for the checkpoints and for the code, and the card lists commercial use among its tags. What that does not cover is the training data or the benchmark suites the card reports against; those are the publisher's, and the numbers are theirs to defend.
On the publisher's own benchmarks it wins the accuracy rows it printed and loses the high-cardinality one, and the Jev side of that table was never measured by them. We ran the two models through the same thirteen adversarial cases and they returned the same label on eleven of them. Anyone claiming a winner from those numbers is claiming it from two different rulers.
Laya arrived as a repository rather than an announcement, which is how the open ones usually arrive. We track both kinds. Leave an email and we will send one note when the next model appears, with the specs read from the catalogue.
One email per model. No newsletter, no forwarding, unsubscribe in one click.
The long version: the three checkpoints and what each one is for, the limits the model card admits to, and the four measurements we ran ourselves.
Thirteen adversarial cases through both models, the eleven they agreed on, and whose ruler each published benchmark number came from.
Hardware, the token budget the options eat into, and the failure modes of running a decision model on your own machine.
Apache-2.0 over three checkpoints, what the card says about commercial use, and what the licence does not reach.
Open the repository → The weights on Hugging Face The specs and our measurements Every record we hold