🎮 The 30-Decisions-Per-Second Snake Demo 0:00
The video opens with the cleanest possible proof of concept: an AI playing Snake, entirely on a local machine, using Laya — an open-source classification model. It makes roughly 30 decisions per second, each in under 33 milliseconds, and after running for a while the snake is over 140 long and "still never fails. It finds a way — the right direction to actually eat the points."
Laya is "basically the same" as Jev, the model that "took the entire web and the entire ML/AI industry by storm": a System 1 model — a special class that only outputs typed, structured decisions, built for classification rather than text generation.
🧠 System 1 vs System 2: What These Models Are 0:28
The framing comes straight from Daniel Kahneman's Thinking Fast and Slow (2011): System 1 is fast, instinctive, and emotional; System 2 is slow, deliberative, and logical. LLMs are System 2 — they reason, chat, find solutions. Jev, Laya, and their ilk are System 1 — they classify, instantly, without generating language.
| System 1 (Jev, Laya) | System 2 (LLMs) | |
|---|---|---|
| Nature | Fast, instinctive, emotional | Slow, deliberative, logical |
| Output | Typed decisions (choice / score / null) | Generated text |
| Examples | Judge distance, localize a sound, 2+2, read a billboard, drive an empty road | Prepare for a sprint, count the A's in a text, reason through a problem |
| Hallucination | Structurally can't — output is constrained to a schema | Possible |
The memorable example: LLMs are System 2, and even they "fail when you say count the number of R's in the word strawberry." System 1 models are the complement — the instant classification layer you bolt in front of the slow reasoner.
🔥 Jev's First Week: Mario, Leads, and Cheap Flights 1:07
Since TypeSafe announced Jev, the demo ecosystem exploded. People wired it into Super Mario Bros, playing in real time (jump, left, move forward, pause). Others used it for high-intent lead scoring — feeding 700 leads and letting Jev classify who'll respond, the perfect message, and how to reach out. The showstopper: pairing Jev with browser-use to book flights — an entire Google Flights booking in ~7 seconds at a fraction of a cent.
The pattern is the same everywhere: a decision model in the driver's seat, calling the shots dozens of times a second while a bigger model does the actual generation only when needed.
🛠️ Swapping Jev → Laya with Claude Code 2:47
There was already an open-source demo called jev-ultrafast (from Gregor at BrowserBase), but it called the closed Jev API. The "even cooler" move was running your own open-weights model locally — faster than Jev, "maybe a little less accurate because it's the very first version," released within days of Jev and working on any Apple Silicon Mac (M1 Max, M3, M2, M4).
The swap itself is a mini-case-study in agentic coding: the host handed Claude Code the source, asked it to swap Jev for Laya, and "it almost one-shotted everything" — no back-and-forth. The resulting demo drives a real Chrome tab via Laya + browser-use: the prompt is "find one-way flights from Zurich to London on October 20, 2026 for one adult in economy; stop when matching flight options are visible", and it picks Zurich, London, the date picker, one-way, and submits — a fully controlled browser session, no Jev API, no cost.
📊 Laya vs Jev: Faster, Open, Slightly Less Accurate 6:18
The honest comparison, stated plainly: Laya is "a little less precise and accurate compared to Jev" — Jev is much more accurate. But as a first version released just days after Jev, it's "a really great start for something big." The context makes it more remarkable: Jev's team spent ~3 years in stealth building the engine and decision model, and open-source "cloned it in like five days."
📝 The API: States, Questions, Typed Answers 9:57
Jev (now generally available, no waitlist) takes two inputs: states and questions. Questions are JSON with three types — choice (pick an option), score (position on a scale), and null (yes/no). You provide instructions, reference state variables in quotes, and define criteria — the definition the model uses to decide.
The walkthrough example is "is food a sandwich?": with food = hamburger it returns 94% true / 6% false; swap in avocado toast and it flips to 6% true / 94% false — per your own definition. The raw response carries the model, answer, token count, request ID, and evaluation time (93ms for that call). Laya runs the same shape — a slightly more complex email-routing example (which department, urgency, refund request) returns billing at 94% confidence in 39ms — roughly three times faster than Jev's timing on the comparable call.
⚖️ Verdict: The Open System-1 Future 11:55
The closing argument is about where this is heading: computer-use and voice agents where a model classifies what to click or say in tens of milliseconds. "It's not going to be closed source anymore — it's going to be literally so fast and so free and open source, and you can run it right inside your computer." A three-year stealth project was cloned in under a week; the future of System 1 classification is open, local, and cheap.
The host is clear-eyed about the current trade-off — Laya trails Jev on accuracy today — but "the future is bright for open source and open-weights lovers." For a model that decides 30 times a second on your own machine at no cost, that's a strong opening move.
💡 Key Takeaways
- System 1 ≠ LLM. Decision models return typed, structured answers for classification — no text generation, so they structurally can't hallucinate.
- Laya is Jev's open twin. Convai Innovations shipped it days after Jev (Sep 18 vs Sep 15), Apache-2.0, ~11K stars.
- It's fast on local hardware. ~30 decisions/sec in the Snake demo, sub-33ms per decision; the MLX runtime hits 7–14ms on M3 Max.
- It's honest about accuracy. Laya is slightly less accurate than Jev today — a first version, cloned in under a week.
- The swap is a one-shot agent job. Claude Code swapped Jev for Laya in the browser-use demo "almost one-shotted."
- Decisions are absurdly cheap. A full Google Flights booking via Jev + browser-use: ~7 seconds, a fraction of a cent.
- The API is three types. Choice (pick), score (scale), null (yes/no) — states + questions + your own criteria.
- The future is open and local. Closed System 1 models now have free, self-hosted alternatives — the lock-in window didn't last a week.
🔗 Resources & Links
- 🐙 github.com/NandhaKishorM/laya — Laya, the open System 1 decision model (Apache-2.0)
- 🐙 github.com/mizorewww/laya-mlx — native MLX runtime (7–14ms on Apple Silicon)
- 🐙 github.com/ipenywis/laya-ultrafast — the Google Flights demo, Jev swapped for Laya
Source video: youtube.com/watch?v=kWToHpdxScE. A companion piece to the Jev deep dives — this covers the open-source counterpart, Laya.