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 — 75 of the 79 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.
The same benchmark account posting its results: Jev still in the lead, but close. It is here in the Laya column because "close" is the finding that matters for an open model running on your own machine — and because the number moves the moment a fine-tune lands.
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 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 first piece of infrastructure here that treats decision models the way Ollama treats LLMs: a daemon, a registry, one command to run Laya, decider, NLI or GLiClass locally behind TypeSafe's own wire format. It is also the largest single discussion of the week on Hacker News, which is why it opens that column too.
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.
The most-read first-hand Laya post in this batch: someone downloads the 421M model, describes what happens when a model refuses to write, and includes the install steps. Seven reactions and four comments, which is more discussion than most of the explainers in the Jev column got.
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.
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.
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.
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.
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.
A short technical walk through the levers that matter after deployment: question design, recalibration, and the limits of fine-tuning a decision model. Produced by a consultancy that links its own write-up in the description, which is worth knowing while watching.
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 well-known practitioner introducing the person who built Laya, framing the work as the open-research predecessor to Jev. Worth a card for the framing alone: it is the credit argument this model's whole reception has turned on.
One `evaluate` tool that any MCP client — Claude Code, Claude Desktop, Codex, Hermes — can call, returning a number or an option that an if-statement can branch on. The smallest useful shape in this batch, and the one that puts the decision where the agent already is instead of in another prompt.
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.
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 macOS coding workspace where the model only chooses from options the host prepared, and the host checks the choice before acting on it. It is the strictest version of the split this topic keeps describing: the model selects, the application decides.
The same channel's plainer piece: Jev and Laya as decision models beside LLMs, and where each belongs in a pipeline. Shorter and less specific than the calibration video, and it names Convai as Laya's origin — a claim we have not been able to confirm from the repository.
A repository that benchmarks Jev, Laya and five open models under three stresses, posted to Hacker News and read by almost nobody — three points. The numbers are the reason it is in this column, not the discussion, and the repository is the thing to open.
A hosted playground for the open alternatives, announced with a price and a compatibility claim: OpenAI-shaped endpoints at half the cost of the hosted model or less. It is the first post here that treats these open weights as something to resell rather than something to run.
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.
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.
An attempt to isolate the reinforcement-learning term in Laya's calibration and measure what it adds, across thirty runs, with the author stating plainly where the evidence stops. The method is the interesting part; the conclusion is narrower than the title suggests.
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.
A creator testing the free version of Jev and ending up at Laya's weights. Half the runtime is promotion for the author's own course, but the middle is a genuine first look at what the two models do differently, which is why it is here.
A short, clear explanation of what Laya returns and why the mismatch with a chat model shows up the moment you ask a ticket-routing question. Nothing first-hand, but it is the plainest write-up of the interface we have seen from a third party.
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.
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.
A ten-minute local comparison of Kev-0.8B against Laya English, on thirty frozen cases and three option orders, covering support routing, missing information, negation and CPU memory. The description says outright that Jev itself was not measured and that this is not an official release — the honesty is why it is here.
A review of Laya as the open-weight alternative to Jev, cross-posted from the author's own site, with the star count, the trade-offs and the parts that did not work spelled out. Published here rather than in the Jev column because the review is about Laya's weights.
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.
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.
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.
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.
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.
A 41-second first-hand run of the MLX port on a Mac Studio: three typed questions back in about 30 ms, the yes/no answers checked against a control message, and one support ticket misrouted at 0.05 confidence. Short, and it names the failure as well as the result.
A careful reader's summary that refuses both camps: the timeline claims are fuzzy, the benchmarks are mixed, and the model is worth following anyway. He puts the numbers beside the cost advantage, which is the trade most of this corpus argues about without stating.
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.
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 '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.
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.
Two models, one question in the title, and a host who runs both rather than reading their cards: what Jev is, then whether the open one is better. The answer is more conditional than the thumbnail suggests, which is why it is on this wall.
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.
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.
Somebody actually installing the open model and testing it rather than summarising the repository: the download, the first call, and what the models do when asked to decide. The channel has no stake in either project, which is the useful part.
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.
The first SDK on this wall written for a language nobody associates with AI work: a support ticket goes in, a readonly PHP class with real enums comes back, and the text never leaves the server because Laya is the one running it. It targets laya-serve rather than the hosted API, and the CI checks its requests against TypeSafe's OpenAPI spec on every change and once a week, which is a more honest compatibility claim than most wrappers make.
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 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.
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.
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 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.
The most concrete answer on this wall to where a decision model actually belongs: downstream of a measurement, never instead of it. OpenCV segments and measures, the numbers are written into the question as text, and the model only says what the numbers mean — with conflicts and low confidence sent to a person. The 3.0 release also trains new decision models from any Hugging Face encoder, which is a page of the Laya story nobody else here has built.
Another Snake comparison, this one with the loop's own numbers: 86.5 decisions a second, a score and a snake length recorded alongside. A game is not a benchmark, and the post does not pretend otherwise — but the rate is real and so is the recording.
The most ambitious claim in this batch with the smallest audience so far: a decision engine that adds an explore-first, crystallise-later loop on top of open models and reports order invariance plus a benchmark table against TypeSafe's hosted endpoint. Thirty-three stars and a marketing site; we read the README and its claims, and ran nothing.
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.
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.
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 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.
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.
Every entry on this page is in one of the columns, with the full list and its filters: Built with Laya (24) · Seen on X (28) · Videos (16) · Threads (11)
The 6 kinds cover 75 of the 79 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 75, 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