Seen on X
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.
26.9.6 is out ! * M5 Ultra optimizations (some apply to all M class) * Laya typed decisions (local-JEV!) * Fixed handling of media and preserve_thinking * UI Updates * Renamed to MLX-Serve (no more MLX Core) * Bonsai-2 Optimizations Sound On 🤘
Opus 5.5 beats Jev and GPT-6 Sol in 3 moves: Rubik’s Cube race We made 4 models run with same limits for all: 20 moves or 5 minutes. Every move = 1 API call. Results: Opus 5.5: solved in 1m 12.87s with the perfect 3 moves GPT-6 Sol: wrong first move, out of time after 4 moves Jev: 20 moves in 20 seconds, ran out of moves Laya: 20 moves in 9.5s, ran out of moves Opus, GPT, and Jev ran via Laya ran locally.
built a malware scanner using laya – a tiny local decision model it can detect malicious files and directories before you open them
💥卧槽！一台 MacBook 就能训出“超级 Jev”？！Naive N0.5 Flash 把决策模型 Jev 玩成了代差，性能碾压 Laya ! 同一套俄罗斯方块、同一序列、同一时钟： ▫️ Jev（云端） 消行 49｜延迟 220.9ms｜直接 TOP OUT ▫️ Laya（本地） 消行 69｜延迟 21.8ms｜快，但打不深 ▫️ Naive N0.5 Flash 自主训出的类 Jev 消行 223｜延迟 52.5ms｜局数直接翻 3～4 倍 这才叫快准狠： 快：本地 50ms 级决策，不跪云端往返 准：不是瞎快，是真清行、真堆低 狠：用 coding / AI4AI 模型自己训领域决策模型，成本比调成熟通用 API 还低 训练和部署都能在 MacBook 上跑完。这不是“调用大模型玩游戏”，是 AI 自己造出一个会打方块的 System-1。 未来可能真是：每个人 DIY 一个领域模型，比天天烧 API 更划算。 #NaiveAIN05 #Jev #Laya #vibe编码 #AI4AI #清华大学 #大模型 #俄罗斯方块
Laya is an open-weight decision model like Jev. Its authors, ConvAI, published a related paper over a year ago. Elixir's Nx was built for running models with native acceleration. I combined these so anyone can run a decision model within an Elixir app!
OPUS 5.5 IS REALLY A DIFFERENT BEAST 🤯 In @aimlapi’s latest test, 4 of the hottest models get locked in a tiny box with a Rubik’s Cube. > Jev and Laya fire off 20 random moves in seconds > GPT-6 Sol makes one bad choice and gives up > Opus 5.5 waits a minute… then solves it in 👏 three 👏 moves ↓
💥惊了！JEMM-27B全方位开源杀到 ！85.7%碾压Laya、工具调用93.3%反超Jev！ Qwen基座专项多模态训练后的JEMM-27B，把图文决策、工具调用、网页操作和审核一起卷进同一个开放模型：不只比Jev 1.13准，还比它更快，JevBench公开题也明显甩开Laya。 核心亮点 🔹原生吃文字+图片，候选选择 / 条件判断 / 打分可直接进Agent决策环节 🔹工具调用准确率 88.7% → 93.3%；截图网页任务 36.0% → 54.6%（+18.6pp，Jev只看文字） 🔹5种文字请求配置延迟全面低于Jev，单题中位数约0.3秒，汇总延迟降31.2% 🔹JevBench 231公开题答对198题，准确率85.7%，高于Laya（58.4%）、Kev、Semlf、Von 🔹对比表里几乎是唯一同时具备：图片输入、任务训练、相对Jev效果更好、延迟更低、开放权重 上手步骤 1️⃣Hugging Face搜 JEMM，下载27B权重： 2️⃣按仓库README装依赖（建议先对齐官方推理适配） 3️⃣加载Qwen基座+JEMM权重，按示例传入文本/截图 4️⃣用选择题、判断、评分接口接进现有Agent工作流，先跑工具调用和网页截图任务验证 推理代码和权重点Hugging Face，搜 JEMM 就能找到。 #JEMM #Jev #Laya #开源大模型 #多模态 #Agent #HuggingFace #GitHub
💥厉害了！0.3秒拍板，大模型终于不当保姆了！将Jev深度融合进Harness，让 Jev 和 Laya 兼而得之！ 大模型是发动机，Harness 才是整台车。每一轮对话里那几百个没人认真做的小决定，终于有人接了，本地执行走 Laya，判定又快又稳。 核心亮点： 🔹Jev 接管 35 个判定点：新任务还是纠错、输出哪几块有用、命令是不是你要的、做完验过没有——一次约 0.3 秒，几乎无感。 🔹本地由 Laya 执行：微决策不下放到大模型，本地 Laya 直接拍板，延迟更低、成本更稳 🔹上下文只留这一步：无用技能/MCP 不进场，工具输出逐块过滤，重复日志直接折叠，过期结果直接扔掉 🔹干活和说话拆成两套模型：Jev 挑出真正的新消息，交给会说人话的模型（如 Claude Opus 4.6）讲给你听，人话不污染干活上下文 🔹蜂群中间加闸门：多只「蜂」分头查，Jev 决定说不说、告诉谁、前后对不对得上，把最该传的信息交给最需要它的子 agent 怎么上手： 1️⃣桌面端：macOS / Windows / Linux 直接装 2️⃣命令行：npm i -g mu-agent 3️⃣GitHub： 模型越强，越不该把微决策也扔给它。Jev 进 Harness，本地 Laya 执行，车才真正能开。 #Jev #Laya #Harness #AIAgent #黑客松 #mu #进化酒馆 #TypeSafe #多智能体
Project: mu→Me parece que me faltó dar muchísimo contexto (mala mía total) Este bot no es el base de CS. Es un proyecto de Github "jrlucas1/csgo-julia-plugin" el cual te permite usar varios modelos (Qwen, Laya, etc.) para que manejen al bot, con diferentes grados de dificultad. ¿Está correcto decir ""IA""? ¿O es incorrecto? Varios profesionales me han dicho que no está mal dicho pero hay otras opiniones, necesito saber! ❤️
🤯 یه نفر به Laya گفت دسکتاپ رو مرتب کن… و واقعاً انجامش داد! بیش از ۶۰۰ فایل رو مرتب کرد و داخل فولدرهای دسته‌بندی‌شده گذاشت. 📁✨ هزینه؟ صفر! 😎 مدل Laya، جایگزین متن‌باز Jev با بیش از ۲۹ هزار ستاره گیت‌هاب، روی InstaCloud سلف‌هاست شده بود. ☁️ وقتی AI می‌تونه کارهای حوصله‌سربر رو خودش انجام بده… چرا دستی انجامش بدیم؟ 😂
A faster, 100% open-source alternative to Jev. It’s called Laya. Both models solve the same problem. You give them unstructured state plus typed questions. Instead of generating a paragraph, they choose from answers you define and return probabilities your code can act on. But they make those decisions differently. Jev is a closed, hosted API. Its architecture and training are not public, but it works zero-shot and supports up to 255 options. Laya is Apache 2.0 licensed, runs locally, and uses open-weight encoder models. Here is how its pipeline works. → It routes by language first. Plain Python selects the English or multilingual checkpoint before inference. → It creates one sequence for each question. Every possible answer gets a `[MASK]` marker. The question and state provide the context needed to compare those options. → It scores instead of generating. A bidirectional encoder and small decision head assign one score to each option. Softmax turns those scores into a probability distribution. → It batches the questions. They run together in one model call, although every question still carries its own copy of the state. This removes network latency and token-by-token generation. In one independent test, Laya took about 35 milliseconds on a local GPU. Jev took roughly 380 milliseconds over the network. Laya also has no per-call API fee, keeps data on your infrastructure, and can run on older GPUs. But it is not a drop-in replacement for every workload. Jev is a hosted generalist that works well out of the box. Laya is a fast base you need to specialize. Laya makes the most sense when you have a stable answer set and representative training data. Fine-tune it for the task, calibrate its probabilities on held-out examples, and send uncertain decisions to a stronger model or human reviewer. Jev gives you stronger zero-shot decisions. Laya gives you speed, privacy, control, and no per-call fee after you teach it your task. The open-source repository is here: If you want to self-host Laya, InstaCloud provides a really nice and easy way to do so. Check this out: If you're new to decision models, I wrote the full breakdown of how Jev. The article is quoted below.
Project: laya→
Laya-MLX is an open source classification system similar to Jev but 50x faster, running locally on device with a maximum of 1GB memory and making decisions at 60 per second, fast enough to play Snake on an M3 Max at full speed. Repo here:
Project: laya-mlx→
Local Laya blitzed other models on RTX 4090 ⚡️ Four local decision models raced down Wikipedia picking out every word that names a centipede and Laya took 3.9 ms a word so it ended up being the fastest overall Run decision models locally ->
decision models + local ai = ❤️ tried Laya (421M) on llama.cpp in a little apple-picking benchmark, it's almost as good as Qwen 4B at 12x the speed.
Laya now supports images, audio, and video along with text, of course. The context window has been increased from 8192 to 73,728 tokens!!. You can attach any LLM as a reader; that means you can attach a 500 M LLM to Gemma 4, Qwen series, GLM series, or trillion-parameter models like Mistral Large 4, Kimi K3(first in the world!), even without much calibration error difference Now you don't need to fine-tune on your dataset; you just fit and calibrate, no gradient descent, and you don't even need a high-end GPU. Includes automated routing, a conformal set, and integrated abstain and outbound(first system decision model). All with an 800-million-parameter model that can even run on your old phone!!! Full blog at: GitHub:
Project: laya→
Acurast: Turning the old phone in your drawer into a computing resource When discussing AI infrastructure, most attention is focused on building increasingly massive data centers. Acurast takes a different approach: leveraging hardware that people already own such as that old phone sitting idle in a drawer. @Acurast What kind of tasks is it suited for? Training a cutting-edge model is a vastly different undertaking from classifying emails, filtering messages, or running a small decision-making model. While phones have limitations, there is still a market for small, repetitive tasks that do not require an entire cluster of GPUs. This is where the intersection of AI and DePIN (Decentralized Physical Infrastructure Networks) becomes compelling. Try it out yourself Laya demos showcase decision-making models running on the CPUs of Android phones handling tasks like email categorization, chat moderation, and screening for prompt injection. Acurast notes that each decision takes approximately 0.2–1 second. You can test it at and see which device is processing your request. The development team also acknowledges certain limitations: classification errors can occur, and queues may grow longer when the volume of requests exceeds a phone’s processing capacity. The trust challenge If a phone belongs to someone else, how can you be sure that the device executing your task is legitimate? Acurast employs hardware-based attestation (Google Key Attestation and Apple App Attest) and monitors for revoked credentials, removing compromised or invalid devices from the pool of those eligible to receive tasks and earn rewards. @Acurast Verification is therefore continuous, rather than occurring only when a device first joins the network. That said, the security model remains dependent on the hardware manufacturers and platform providers. The role of ACU ACU serves several defined functions: covering network fees, incentivizing the provision of computing power, staking, and governance. The most notable mechanism is "Staked Compute": providers lock up tokens to commit a specific amount of computing power, while ACU holders who lack hardware can delegate their tokens to these providers. Benchmarks and "heartbeat" signals monitor capacity and availability, ensuring providers have an economic incentive to honor their commitments. It is worth noting that the tokenomics include an annual inflation rate of 5%, with 70% of that allocated to the Staked Compute Pool. Therefore, staking rewards should not be confused with revenue generated from customers paying for computing services. While incentives can help build supply, it is the return of actual customers that truly validates the value of that supply. Key metrics to track: •Number of paid tasks and the rate of returning developers •Cost per successfully completed task •Stability under sustained load •Growth in usage relative to token-based incentives These metrics offer a much more meaningful picture than simply counting the number of registered devices. How to get started? The "Cloud Rebellion" program allows you to explore the ecosystem by completing tasks, deploying applications, and onboarding a supported device to the network. @Acurast You earn "MIST" points which are distinct from ACU tokens. My advice: try out the demo and use a spare device before making any further investments.
An AI just beat me at Snake. Seriously. It was running on a single Android phone, making decisions in about 0.2 to 1 second. No data center needed. The model is Laya, an open “System One” decision model from ConvAI Innovations, running on @Acurast decentralized phone network. What makes this different from a typical AI demo? Laya doesn’t generate text. It makes decisions. Picking an option. Sorting spam from real messages. Blocking prompt injections. Even playing Snake. All in under a second. And it’s not running on some huge GPU cluster. Just one phone, costing less than 1 $ACU a day. There are 9 live demos right now. A mail sorter, a chat moderator, a newsroom that catches clickbait, a prompt injection guard and even a “Swipe for me” dating style demo. Different use cases, same open-source model, all running on phones. It got me thinking. We keep hearing that AI needs more GPUs and bigger data centers. But does every AI task really need that much computing power? What if our phones could handle the quick decisions, like routing, filtering and moderation. While the heavy work stays in the cloud? That’s what Acurast is exploring with this demo. And honestly, this feels like a more practical use case for DePIN than most “run a node and earn” projects I’ve seen. So, what do you think? Is this where edge AI is heading, or is it just a cool party trick?
Jev + Laya + any AI agent is an absolutely insane stack Jev became one of the most talked-about AI releases almost overnight, but most people still have no idea how to use it beyond isolated demos - especially together with Laya, Grok Bot, Claude Code and Codex So I mapped the complete architecture into a 12-page guide explaining how to combine all of them into one decision-and-execution system - and the result is genuinely ridiculous: step 1 → stop asking one LLM to do five different jobs: state, judgment, generation, execution and authority should be separate layers step 2 → use Jev as the escalation layer: it handles difficult routing, evidence verification, completion checks and high-consequence decisions through typed answers step 3 → use Laya as the local fast path: it handles frequent classification, scoring, filtering and worker selection without sending every decision to a cloud model step 4 → put both behind one decision gateway: Laya and Jev can accept similar choice, score and yes-or-no questions, but their confidence values need separate thresholds step 5 → keep project state outside the agents: goals, artifacts, evidence, gaps, risks, budgets and approvals become the shared source of truth step 6 → build the worker menu before asking a model to choose: only include agents that exist, are available, have the required tools and are allowed to access the data step 7 → give every executor a different job: Grok Bot handles apps, browsers and routines; Claude Code handles deep repository work; Codex handles implementation, testing and review step 8 → turn every assignment into a bounded packet: one owner, one objective, approved inputs, expected artifacts, forbidden actions and an exact definition of done step 9 → run the hybrid decision loop: Laya answers locally first, Jev receives uncertain or high-risk cases, and a human reviews consequential disagreements step 10 → never average confidence blindly: if Laya and Jev disagree, preserve both distributions, inspect the evidence and route the case through an explicit review policy step 11 → gate effects instead of tool names: reading, searching, testing and drafting can run automatically; publishing, deploying, spending, deleting and exposing secrets still require approval step 12 → test the whole system before giving it autonomy: run shadow mode, measure disagreements, inject failures, test rollback and automate only the safest branches first the result: Laya filters routine decisions, Jev judges difficult boundaries, Grok Bot, Claude Code and Codex execute the work, deterministic code controls the system and you approve the consequences Save this, then send the complete 12-page Jev + Laya + AI Agents guide to your Claude Code or Codex instance and build the stack ↓
I finally tried @Acurast Laya demo and I get it now. For weeks I kept seeing “phones running AI” and thought okay cool concept, but what does that actually mean? Then I played the Snake demo. An AI model, running on a single Android phone, making a move every 0.2-1 second. No data center. No GPU cluster. Just a phone...! And it’s not just Snake. There’s a mail sorter (90% accuracy), a chat moderator, a prompt injection guard, even a “Swipe for me” dating-style demo. All powered by the same open-source model from ConvAI Innovations. Here’s what clicked for me: we keep saying AI needs more GPUs and bigger data centers. But what if most everyday decisions spam filtering, content moderation, quick routing don’t need that? What if your phone could handle the “fast decision” layer while the heavy stuff stays in the cloud? That’s what Acurast is testing with Laya. And honestly? It’s the first DePIN use case that actually made sense to me. Not run a node and hope for rewards. Actual AI decisions, running on actual phones, for real use cases. What do you think ? Is this the future of edge AI or just a cool demo? Here’s : Code : ansk5e
🆕 Guía de Laya.cpp (Alternativa a JEV) ✅ Modelo de IA muy pequeñito (< 1GB) ✅ Posibilidad de uso en local ✅ Laya multilingual (incluido español) ✅ Rendimiento: ~230ms (Jev) vs ~33ms (Laya) ✅ Open Source (y gratis)
Eikos está aberto (MIT). Modelos de decisão (System One) de 4B e 27B: decidem numa única passada e dizem a probabilidade de cada opção. • 27B: 82,9% no JevBench hard (Jev: 73,0) • 2,4% de erro com ≥90% de certeza (Jev: 5,9%) • 64k de contexto Mesmos itens, mesma pontuação: 8 baterias contra o Jev e a Laya. Pesos, dataset e código:
Project: eikos→해커뉴스에서 난리 난 'Ollaya( 역대급인 이유: 1. "Ollama의 편안함을 의사결정 모델로" - 복잡한 파이썬 환경이나 CUDA 세팅 필요 없음. - 터미널에 `ollaya run laya` 딱 한 줄만 치면 Mac GPU(MLX)나 CPU에서 초경량 의사결정 모델이 0.1초 만에 실행됨. 2. 쓸데없는 텍스트 생성 0% (몇 밀리초 만에 정밀 확률 반환) - 무거운 LLM처럼 문장을 주절주절 뱉지 않음. - 고객 메시지 하나를 넣으면 단 1번의 연산으로 [환불 요청: 90%, 분노 지수: 1.76/3, 이탈 위험: 61%] 같은 가중치 확률을 수십 밀리초 만에 뱉어냄. 3. 기존 Jev / TypeSafe 코드 100% 호환 - 기존에 짜둔 Jev 코드가 있다면 환경변수(BASE_URL) 하나만 로컬 포트로 바꾸면 끝. - 클라우드 유료 결제하던 비용이 '완전 0원'으로 떨어짐. 4. Cursor & Claude Code 전용 MCP 공식 지원 - `claude mcp add ollaya -- ollaya mcp` 명령어 하나로 내 AI 코딩 에이전트에 직결 가능. - 에이전트가 조건 분기나 코드 분류를 판단할 때 비싼 최상위 모델을 안 쓰고 로컬 Ollaya를 호출해 API 비용 90% 이상 세이브. 5. 어디에 써먹을 수 있는가? ① 고객 문의 자동 분류 및 담당자 자동 라우팅 ② AI 에이전트의 다음 행동(Tool Call) 초고속 분기 판단 ③ 스팸 메시지, 악성 댓글, 비정상 결제 실시간 필터링 ④ 문서/이메일 긴급도 판별 및 태깅 자동화 비싼 LLM 호출하느라 에이전트 루프 비용 터지던 분들은 무조건 저장해두시길. 🔗 공식 사이트: 🔗 깃허브:
Project: ollaya→
Laya Jev can locally Sort 600+ desktop files into folders. Laya is the Jev alternative people are quietly running locally.
Me piden por todos lados que meta Jev en gentle-ai. Lo probé con código real, junto con Laya y Kev. Uno me dejó la GPU al 99%. Otro acertó menos que mi heurística. Y el que mejor anduvo no era ninguno de los que me pedían. Video en comentarios 👇
Full interview at AIM on my journey and how I built Laya
My Swift package supports Laya, which runs on the Apple Neural Engine and can triage 500 emails in under a second.
Project: system-one-foundation-models→
Why put an AI guard at the entrance? Because Agents read both user instructions and untrusted content. If an email contains a hidden command, the Agent may treat it as part of the task. That becomes dangerous once tools or business data are involved. @Acurast built Jailbreak the Guard to test this problem: • Submit a prompt • Laya decides whether to allow or block it • The model identifies the likely attack type • The decision runs on an Android phone in the Acurast network It will not catch every adversarial prompt. But as a first filter before permissions and tool calls, this is a practical use of decentralized compute. The real test is whether developers keep deploying workloads and paying for them with $ACU. #Acurast #AI #DePIN
🚀 Rapid-MLX 0.15.2 is out! The headline: Native System One support on Apple Silicon! System One isn't just another chat endpoint. It’s a dedicated local decision server for apps that need fast, structured answers: yes/no judgments, classification, routing, and candidate ranking. What's new in Rapid-MLX: ⚡️ CLM-8B — a native MLX Qwen3-8B encoder with contrastive projection heads 🧠 Laya — an ~807 MiB low-latency backend 📊 Typed endpoints: /v1/systemone (noul, choice, score) & /v1/rank 🛡️ Enterprise-ready: API keys, bounded concurrency, and state/action caching Performance on M3 Ultra CPU: • Laya: warm 3-question request in ~170ms; single decision in ~52ms. • CLM-8B: cached decisions in <1ms server time. Give it a try:
天下武功，唯快不破 JEV很好，但是我选择laya Laya是一套开源的结构化判断模型 最大优势其实就是可以本地部署 可以魔改训练 比如BSC meme，我给他接了价格、曲线进度、流动性、买卖流、Top10 持仓、开发者持仓、聪明钱 再套到一个meme早盘流量轮动的策略里边 跑了一天，两个模型对比 jEV跑了200多笔，输17U Laya跑了312笔，胜7U 建议持续深耕高速决策模型 还有很深的应用场景可以挖掘
What if your next AI model runs on a phone, not a data center? System One models handle decisions like spam detection, moderation, routing, and prompt safety. Laya puts these workloads on phones through Acurast’s decentralized cloud. ~0.2s decisions. Open model. Private by design. AI doesn’t always need to scale up. Sometimes, it scales out. Read the full story 👇
Posted a Laya demo on X? Mention “Laya” and it gets picked up automatically, or submit the project.
