Hosted Laya: $1 free, no card
laya.tools
Submit

Seen on X

What people are building with Laya.

Demos, games, ports and benchmarks posted on X, picked by hand. Each one links back to the original post and, where there is one, to the project in the directory.

Chuck Bass

@ChuckBass14291 · Sep 23

Laya Demo uses typed decisions for moderation, routing, and filtering

不要再让大模型生成一堆文字再靠解析器猜答案了，真正高效的决策系统，应该直接输出“选择什么 + 概率多大 + 我有多确定”。 📦 应用档案 Laya Demo 🎯 Space ID：convaiinnovations/laya-demo 实时点赞：❤️ 164 前端/部署：Gradio + Hugging Face Spaces 技术定位：Fast System 1 decision engine——面向低延迟场景的类型化决策引擎，不生成文本，只输出结构化决策与校准概率。 它最值得研究的地方，不是 UI，而是把“语言模型生成”重新拆成了“决策模型 + 业务代码”。 🛠️ 1. 核心范式：从生成式回答切到 Typed Decisions Laya 支持三类原生决策： choice：从多个选项中选择，并返回每个选项的概率； score：在预定义评分等级上定位，并返回概率； noul：判断真假，直接输出概率。 关键变化在于：模型不负责生成自然语言，因此没有“生成 → 解析 → 正则提取 → 判断格式是否正确”这一整套脆弱链路。 输入是 state + typed questions，输出直接是类型化结果。 这对 LLM Guardrails、RAG passage filtering、内容审核、模型路由尤其重要：应用真正需要的往往不是一句漂亮的回答，而是一个可以直接进入 if/else 的可靠信号。 🛠️ 2. 把阈值从模型里拿出来：模型负责概率，代码负责决策 README 里一个非常关键的设计是：thresholds live in the app, not in the model。 例如支持分流、钓鱼邮件检测、审核或模型路由时，Laya 先完成一次批量问题推理，然后由普通业务代码根据概率和 confidence 决定下一步。 这其实是一种很“工程化”的解耦： 模型负责回答“概率是多少？” 业务层负责回答“超过多少才执行动作？” 相比让 LLM 自己输出“我认为应该拦截”，这种架构更容易测试、回归和审计，也更适合生产系统。 🛠️ 3. ZeroGPU + Transformers：把推理资源做成按调用计费的运行时 源码里最值得注意的细节，是 spaces 必须在 torch 之前导入。 原因不是代码风格，而是 Hugging Face ZeroGPU 的运行机制：spaces.GPU(duration=60) 为被装饰的函数动态附加 GPU。如果 torch 提前初始化 CUDA，ZeroGPU 的补丁可能失效，最终触发 “No CUDA GPUs are available”。 因此它实际上采用的是： Gradio UI → Space 函数调用 → ZeroGPU 动态挂载 GPU → Transformers / Laya 推理 → typed decision → Python 阈值逻辑 这种设计特别适合独立开发者：不用让 GPU 永久在线，而是在真正执行推理时申请计算资源。 🌍 另一个很容易被忽略的工程点，是 Multilingual routing。 Laya.Router 会根据输入文本的 script，在 forward pass 之前决定使用哪个 checkpoint： laya → English laya-multilingual → 100+ languages laya-typed-decisions → typed-decision workflows 为什么要提前路由？ 因为“模型不认识这门语言”时，它自己的 confidence 未必能可靠地告诉你这一点。 这其实比单纯堆一个多语言模型更有工程价值：先判断“该交给谁”，再让模型做决定。 真正值得复刻的，不是它的 Demo，而是这套架构思想： 不要让生成模型承担所有事情。 把系统拆成： 输入状态 → 类型化问题 → 一次批量推理 → 概率/置信度 → 业务阈值 → 动作。 这样一来，模型变成“概率决策器”，而不是万能聊天机器 🔗 在线体验地址：

♥ 2↻ 0169 viewsView on X
Project: laya-demo→

Frankenstein (Hao)

@hbcbh1999 · Sep 27

laya-mlx plays 2048 locally with a move-by-move decision breakdown

No Jev API access at the moment.😂 I used the next best thing available - laya-mlx on huggingface to test Jev-style decision making to play the popular 2048 puzzle game. The decision making is superfast for each play. No speed-up in the demo. Everything was done locally on my Macbook. There is a little breakdown of decision making on each move at the end. Enjoy your Sunday, X!

♥ 2↻ 0153 viewsView on X

ジョシュ｜AI研究・個人開発

@anIgnorantD · Oct 5

A tool uses Laya Multilingual for browser tasks and JSON processing

Laya Multilingualを落としてツールを作ってみました ・ブラウザユース…処理は人間より早いが、指示文を調整しないと動いてくれない。雑に投げられない ・jsonファイルの処理…あまり早くないが、精度はギリギリ及第点。こちらも調整が必要 といったところなので、繰り返す定型業務向け

♥ 2↻ 029 viewsView on X

Dima Nurm

@NURM_Dima · Oct 7

EmbeddingGemma decision models benchmark against Laya MLX on an M3 Mac

Can an embedding model learn to make decisions, instead of just finding similar text? We took the 271M text encoder from EmbeddingGemma 2 and trained it to choose between actions described in plain language. First, we fine-tuned the entire encoder together with a small decision head. Then we trained the head further to improve UI command selection while preserving the new skill. On our synthetic English test: • Accuracy on unseen attribute values and combinations rose from 47.66% with the original encoder to 83.94–95.23% across two training seeds. • UI command selection reached 99.61% for both seeds. On an M3 Mac, warm median decision latency was 17.9–31.5 ms, compared with 19.5–21.1 ms for our installed Laya MLX reference on the same workload. There’s a trade-off: one seed passed all our accuracy checks; the other still regressed on two older tests. We’re publishing both, including the failures. The result is a small, locally runnable decision model. It chooses an action; it doesn’t generate reasoning. These results don’t establish general superiority over Laya. Weights, Python/Swift inference code and full results:

♥ 2↻ 1256 viewsView on X

链上码农

@coder_onchain · Nov 6

A technical overview compares Laya with Jev and reports benchmark results

前脚 TypeSafe 刚发布闭源的“系统一模型” Jev，仅隔 3 天（2026年9月18日），开源社区就火速交出了完全免费的平替答卷！🔥 由 Convai Innovations 推出的 Laya 正式开源，采用极其宽松的 Apache-2.0 协议。把毫秒级、类型安全的机器决策能力，彻底搬到了你的本地显卡上！👇🧵 ⚡ 什么是 Laya？ 非自回归 + 单次前向传播和 Jev 一样，Laya 不陪你聊天，也不逐个 Token 吐字。它基于 ModernBERT (421M) / mmBERT (322M) 编码器架构，外挂专用决策头，并采用 RLCD（校准决策强化学习） 训练。 输入一段上下文（State）和一组问题，只需一次前向传播（Single Forward Pass），就能并行输出所有答案、校准概率分布与置信度。 在单张 T4 GPU 上，中位延迟低至恐怖的 32.8 ms ~ 39.5 ms！ 🛠️ 100% 兼容 Jev 思路的三大原语 + 多语言生态Laya 原生支持三大文本决策原语： • choice：多选路由，返回选中项与概率分布 • score：有序量表打分，输出连续加权期望值 • noul：是非二元判断，直接输出 $P(\text{true})$ 生态极其友好： 🐍 Python：pip install laya 开箱即用 🟩 Node.js：社区提供 @receptron/laya（基于 ONNX Runtime，免 Python 环境） 🍎 Mac：支持 Apple Silicon MLX 本地硬件加速 🌍 多语言：laya-multilingual 原生支持 100+ 种语言（1024 上下文） ⚖️ 客观避坑：Laya vs 闭源 Jev 怎么选？ Laya 官方 Model Card 非常坦诚地指出了它的核心取舍——“微调猛如虎，零样本需谨慎”： • 零样本（Zero-shot）较弱： 未微调的 Laya 在 typed-decisions 基准上仅 36.2%，且面对超 20 个选项的高基数分类时表现会下降。开箱即用的通用零样本能力，目前仍是闭源 Jev 更强。 • 微调后（Fine-tuned）反超： 一旦用目标数据集微调，laya-typed-decisions 准确率飙升至 76.6%，直接反超 Jev 的 72.7%，且推理速度比 Jev 云端 API 快 7.8 倍，边际调用成本为 $0！ 💡 总结： AI 工程化的最佳基座不要把 Laya 当作开箱即用的万能神仙，它的真正定位是 “A fast base to specialise（专为业务微调而生的高速基座）”。 如果你有明确的业务路由、工单分类、安全风控数据，拿 Laya 微调一个专属的 30ms 本地“系统一”守门员，隐私安全、零 API 账单、极致低延迟，这才是开源赋予 Agent 架构的最大红利！ 🔗 Hugging Face / GitHub 搜索：Convai Innovations Laya #开源 #AIAgent #Laya #TypeSafe #Jev #LLM #MachineLearning

♥ 2↻ 0259 viewsView on X

Shreyansh Patni

@shreyanshpatni_ · Sep 25

Laya-MLX runs typed decisions offline on Apple Silicon

Run AI inference locally on Apple Silicon—without cloud APIs or PyTorch. Laya-MLX is an open-source MLX runtime for running Laya typed-decision models natively on Mac, with: → Up to 395 decisions/sec → 0 output tokens for typed decisions → ~7.4ms median latency on M3 Max → Fully offline inference → Python API + CLI → Apache 2.0 license Free and open source. Comment “Laya” for the link.

♥ 1↻ 1398 viewsView on X

恒星sun

@vintcessun · Sep 25

@receptron/laya runs typed decisions in Node.js without Python

Agent 的每个小判断，都要交给生成式模型吗？ Laya 不生成文本，而是把工单等状态和多个问题一起送入模型，一次推理给出分类、等级评分和是非判断的概率。这个 TypeScript 包通过 ONNX Runtime 在 Node.js 中运行，不需要运行时 Python。挺适合流程分流，不过权重约 1.7GB，部署时得留意内存。

♥ 1↻ 1186 viewsView on X
Project: laya→

varun bhardwaj

@varunPbhardwaj · Sep 29

Qualixar Jev Decision Layer adds recipes, MCP tools, and optional local Laya

I've been watching something interesting happen over the last couple of weeks. My GitHub and X feeds are suddenly full of Jev and Laya experiments. People are showing routing. Token reduction. Local inference. Fast typed decisions. And honestly, I think the underlying idea matters much more than another model launch. TypeSafes Jev is built around a very different primitive : state + a bounded question → typed probabilistic decision. Choice. Score. Noul.TypeSafes Own System One workflow evaluations report 193.6× faster and 444.6× cheaper than their LLM reference on those workflows. Laya and Laya-MLX have made the same idea interesting locally as well, with very fast typed decisions running on Apple Silicon. But while watching all these demos, I kept coming back to one boring question: How does somebody actually USE this every day? Not just an AI researcher. A manager. A developer. A freelancer. A content creator. Because a fast model call is not a workflow. Someone still has to decide: Which bounded question should I ask? What are the allowed choices? Can this data leave my machine? Which provider should receive it? How confident is confident enough? What happens when the answer is uncertain? Who is allowed to execute the recommendation? And six weeks later — can I see what decision was actually made? That was the missing layer for me!!! So I built Qualixar Jev Decision Layer. Not another Jev demo. A reusable layer around the decision primitive. The current open-source release contains: → 38 reusable decision recipes → 20 MCP tools → 5 agent-harness adapters → 114 offline fixtures → hosted Jev + optional local Laya → local policy gates → inspectable decision receiptsAnd the recipes are no longer only developer examples. A manager can evaluate a work item against supplied priorities. A creator can choose between a Short, newsletter or carousel from a brief. A freelancer can route an enquiry. A developer can narrow tools, files, skills, tests or review attention. Same basic primitive. Different decision recipe. One shared layer. There is another boundary I care about: the model does not get execution authority.Jev or Laya can recommend. The local layer can evaluate that recommendation. The host — Codex, Claude Code, VS Code, Hermes or Antigravity — still owns the actual action and its permissions. I think the architecture becomes obvious once you see the whole loop: context → recipe → Jev/Laya → local gate → advisory result → receipt → host Thats the layer I felt was missing! Repository: Particularly interested in one question: What bounded decision are you still wasting a frontier-model turn on today? #opensource #jev #typesafe #laya

♥ 1↻ 0104 viewsView on X
Project: jev-decision-layer→

Akoji

@Akoji_69 · Sep 29

Laya-MLX benchmarks, fine-tuning results, and local application examples

EVERYONE posting Laya benchmarks is benchmarking the wrong thing. Base Laya LOSES to Jev. Convai's own numbers: 0.362. Random guess: 0.318. Majority-class baseline: 0.461. It's below a constant string. The viral "50x faster than Jev" isn't in the repo. The repo says 7.8x. The actual story is better. Thread ↓ [2/9] What Laya-MLX actually is: a 421M encoder (ModernBERT-large) that never generates a token. You give it a state + a typed question: → choice (pick from named options) → score (level on a rubric) → noul (P(true)) One forward pass. Probabilities out. Nothing to parse, nothing to hallucinate. [3/9] On an M3 Max, measured by the port author: • 7.4 ms — multilingual 322M, one question, P50 • 13.4 ms — English 421M, P50 • 943 MB peak RAM • 0 output tokens • no PyTorch, no Transformers, no API key pip install laya-mlx Jev: 70–500 ms, $0.042 / 1M input tokens, US-west-coast only. [4/9] What people actually built with it: • 1,000 emails → 6 folders on an M3 Air, 28.6s, $0, 0 MB swap (@NURM_Dima) • Inbox triage + 100 SAP decks + blog taxonomy, fully offline, $0/call (@Raju_M_A) • OpenClaw cascade: Laya 85% @ 27.8ms → Jev 90% @ 1168ms, 14/20 decisions never reached the paid API (@aaronedell) • Snake at 75 decisions/sec, under 1GB • prompt-injection gate before your LLM call • pg-laya, Needle browser search, Unity, ComfyUI router, agent-drift monitor [5/9] Now the part that matters, and nobody posted it. Anthus ran a pre-registered paired test. Same 140 labels, same 600 held-out items, one variable: Laya zero-shot —————— 0.722 Jev zero-shot ——————— 0.768 Jev + feedback loop — 0.870 Laya fine-tuned ——— 0.896 140 labels. 100 seconds of training on an M1 Max. Laya is the only one of the three you own. [6/9] Why the base model is bad and the fine-tune is great: The base checkpoint is a 421M BERT. It has no world knowledge. It can't tell you what your code does. Fine-tuned on your labels, it learns your taxonomy in an hour. That's the whole product. Convai says it themselves: "Laya is a fast base to specialise, not a zero-shot decision engine." The author of Laya on X: "Base model has limitations." [7/9] The pattern that's working in production is a cascade, not a replacement: Laya decides → confidence ≥ 0.60 → execute else → escalate to the good model @yibie measured it: at threshold 0.60, Laya matched Jev's 78%. You pay for the cheap 80%, not the expensive 100%. [8/9] Ship it if: you're on Apple Silicon, your decision is constrained to named options, and you have ~200 labels. Don't if: your input is long, you have 70+ options, or you need facts. Real cliffs: • 512 token context (EN) / 1024 (multilingual) — truncates silently • options share one token budget — Banking77 (77 labels): Laya 0.425 vs Jev 0.870 • ships over-confident: ECE 0.466 → 0.081 after you refit temperature • noul can follow its labels not your text (#156) — ask it as a 2-option choice • act_probability is useless (AUROC 0.30). gate on confidence (0.77) • ~8ms per extra question — it re-encodes the state [9/9] The one thing nobody tells you: it's not "AI that replaces Jev." It's a 943MB local decision layer you can fine-tune on your own labels, running at 140 decisions/sec, for $0. That's not a frontier model. It's something frontier models are bad at. · Apache-2.0

♥ 1↻ 1119 viewsView on X
Project: laya-mlx→

Stanislav Sorokin

@stas_sorokin_ · Sep 30

Fine-tuned Laya reaches 85.5% decision agreement and handles 52% of live picks

Laya vs Jev: a 322M open model on a Mac mini learned our decision API's picks. 13% → 85.5% in 3 training rounds. Jev is our decision API: one closed choice, one answer, about a second. Fast, but every call is a paid API call. So we trained Laya on 7,396 of Jev's real decisions and tested it on 2,371 it never saw. Same pick as Jev: → Out of the box: 13.3% → Round 1, our real decisions: 72.1% → Round 2, look-alike options: 77.8% → Round 3, more layers, two passes: 85.5% Right kind of choice: 58.6% → 92.0% Picks it can make alone at 99% confidence: 0% → 75.4% The twist: it got faster while it got smarter. One pick went from 912 ms to 481 ms. Live since last night: Laya makes 52% of the decisions, 0.63 s each vs 1.16 s for Jev. When it is unsure, Jev decides. Which small decision in your stack is still paying a big model? Repost this now, because most AI teams pay an API for choices a small model learns in three rounds. Follow for more measured Laya and Jev builds.

♥ 1↻ 01.6k viewsView on X

Posted a Laya demo on X? Mention “Laya” and it gets picked up automatically, or submit the project.