Open-Source Decision Model Laya Tested: Local Classification Decisions in 30 Milliseconds

The Rise of System E Models: Laya as an Open-Source Alternative to Jev

An AI playing Snake on a local machine — making nearly 30 decisions per second, each taking under 30 milliseconds. This is not the kind of speed you'd expect from a typical large language model. What the video's author demonstrates is a new classification and decision model called Laya, running entirely locally, reaching a snake length of over 140 without a single mistake, always finding the right direction to score.

This class of model belongs to what's known as "System E" (systematic) models, designed specifically for structured decision-making and classification. They share the same paradigm as the Jev model that has been making waves in the machine learning community. Unlike traditional LLMs — where you ask a question and get a text response — these models are built for classification tasks: give them a problem with discrete categories, and they return a decision in sub-millisecond time.

A note of clarification: the video contains some naming errors (Layer/Laya, Jeff/Jev, etc.) and some technical descriptions are fairly broad. Readers should refer to official documentation for accuracy. This article is based solely on that video, and the performance figures cited have not been independently verified.

The Wave of Applications Sparked by Jev: From Super Mario to Flight Booking in 7 Seconds

Since TypeSafe AI released Jev, experiments have been proliferating rapidly. The video highlights several notable examples:

Someone used it to play Super Mario Bros. in real time — you can clearly see the model rapidly issuing commands like "jump, move left, advance, pause" all the way to completion, made possible by its extremely low decision latency.

In a marketing use case, someone fed 700 sales leads to Jev, asking it to classify which ones would respond, what the ideal message for each user would be, and how to reach them.

Perhaps the most striking example is automated flight booking: the developer behind Browser Use combined it with Jev to have the AI open Google Flights, select dates, and filter for the cheapest flight — the entire process took around 7 seconds and cost roughly $0.0039. This combination of speed and near-zero cost is exactly where System E models shine.

From Closed-Source API to Open Local Deployment: Why Laya Matters

Jev itself is a closed-source model served through a hosted API. While its pricing is practically negligible, it still requires cloud dependency. Laya changes that — it's an open-source, open-weights model that you can download and run locally.

According to the video, Laya was released just two to four days after Jev and runs smoothly on M1 Max, M2, M3, and M4 MacBook Pros and Macs. The author's approach was straightforward: take an open-source demo project built on the Jev API called "Jev Ultra Fast" (built by Gregor from Buzzerbase), and have Claude Code port it to use Laya instead.

The result impressed the author — Claude Code completed the integration from Jev to Laya in essentially one pass, producing a demo that runs entirely locally, for free, with no API costs whatsoever. Beyond Laya, the video also mentions another model in a similar family called Cave, built on Qwen, available in 9B, 4B, and 800M parameter sizes — also open-source and locally runnable.

"Open weights" vs. "open source" are two terms that are often conflated but mean different things. Open weights means the model's parameter files are publicly available for local inference, but the training code, datasets, and fine-tuning pipeline may not be disclosed. True open source requires all of the above to be released under an open-source license, allowing others to reproduce the training process and build derivative works. Meta's LLaMA series is a classic example of "open weights but not fully open source." For everyday users and application developers, the practical difference is minimal — being able to download weights and run inference locally is sufficient for privacy protection and zero API costs. But for researchers or teams seeking deep domain customization, transparency around training data and procedures is critical. The video's use of "open source" to describe Laya does not clearly distinguish between these two concepts; readers should check the specific license terms on its release page before deploying it.

Live Demo: Browser Automation and Document Recognition

The ported demo uses flight booking as its example: the prompt asks to "find a one-way economy flight from Zurich to London, show only matching options, do not actually book." After clicking start, Laya works with Browser Use to automatically open a new tab, select departure and destination cities, open the date picker, choose a date, switch to one-way, and submit to view all available flights — the whole sequence moves faster than the eye can easily follow.

In another demo, the prompt asks to open an article about "controlling browser agents with limited choices." The model is able to infer the target page and automatically click to open it, demonstrating strong instruction-following and classification capabilities. The author acknowledges that Laya currently lags behind Jev slightly in accuracy — but for a first release that's only a few days old, it's already an impressive starting point.

What the API Looks Like: JSON Output from a Single Classification Decision

The video also walks through the API interaction pattern for System E models. The model accepts two inputs: a state and a question, both structured as JSON.

Using a "sandwich determination" example: a state variable (e.g., food = burger) is substituted into a question, along with a definition (e.g., "true if meat, cheese, vegetables, or spreads are between structurally supportive bread"), and the model returns a structured result: sandwich determination 94% true, 6% false. Swap the food for something that doesn't fit the definition, and the result flips to 94% false. The entire decision takes 93 milliseconds.

In a more advanced email classification example, the model can determine which department an email belongs to (billing/technical/sales), while also outputting fields for urgency level, churn risk, whether it's a refund request, and confidence scores (e.g., billing 94%, language English) — all within 39 milliseconds, which the video claims is roughly one-third of Jev's actual latency.

Confidence scores in classification model outputs are typically presented as probability distributions, reflecting the model's degree of certainty about each category — but they are not the same as accuracy. A model can assign 95% confidence to a wrong answer ("overconfidence") or only 60% to a correct one ("underconfidence"). A well-calibrated model requires that when the model says a category has 70% probability, that category genuinely appears roughly 70% of the time across a large sample. In practice, confidence scores are mainly used to set decision thresholds — for example, only auto-executing classifications above 85% confidence, and routing everything below that threshold to human review. The 94%/6% distribution shown in the video indicates the model is fairly certain about that particular input, but a single demo cannot reflect how well the model's confidence is calibrated on edge cases or adversarial inputs. Systematic evaluation on representative datasets is required before production deployment.

System 1 and System 2: The Cognitive Theory Behind Model Classification

The video borrows from Thinking, Fast and Slow to explain where this class of models fits. The book distinguishes two cognitive systems: System 1 is fast, intuitive, and emotional — responsible for judging distances, locating sounds, completing familiar phrases, doing simple arithmetic, and reading billboard text. System 2 is slow, effortful, and logical — handling things like preparing for a sprint start, focusing on a specific person in a noisy room, or counting the occurrences of a letter in a text.

The author points out that current large language models lean toward System 2-style reasoning — and yet still stumble on questions like "how many R's are in the word Strawberry." Classification models, by contrast, are closer to System 1's rapid intuitive judgments. The analogy isn't perfectly rigorous, but it offers an intuitive framework for understanding why dedicated fast-decision models are needed.

Daniel Kahneman's dual-system theory, introduced in Thinking, Fast and Slow (2011), was originally a psychological framework for describing human cognition — not designed with AI in mind. System 1 corresponds to the brain's automatic, unconscious processing, relying on pattern matching and heuristics with minimal attentional resources; System 2 corresponds to slow reasoning that actively draws on working memory, capable of handling novel problems but prone to errors or "lazy" shortcuts (reverting to System 1 heuristics) under high cognitive load. When borrowing this framework for AI, it's worth noting: the "slowness" of large language models comes from the sequential computation of autoregressive token generation, not from any genuine depth of reasoning; the "speed" of classification models comes from constraining the output space to discrete categories, avoiding the computational overhead of open-ended generation. The fundamental difference lies in the size and structure of the output space, not cognitive depth. The practical value of this analogy is helping product designers decide: which business scenarios are well-suited for fast classification (intent recognition, entity extraction, routing), and which must be reserved for generative reasoning (writing proposals, complex dialogue).

Looking Ahead: The Future of Fast Local Decision-Making

The author expresses strong optimism about this direction: Jev's team reportedly spent three years in stealth refining their engine, yet the open-source community cloned a competitive alternative in five to seven days. He expects more locally-run, fast, free, open-source decision models to emerge — applied to computer operation automation, voice interaction, and similar use cases. Imagine a model that classifies "what to click next" at sub-millisecond speeds to control your computer, paired with voice mode for real-time instruction execution.

For fans of open-source and open-weights AI, this is genuinely a trend worth watching. That said, some perspective is warranted: Laya is still in very early stages, its accuracy and stability remain to be proven, and all performance figures cited in this article come from a single video demo. Actual results should be measured against official benchmarks.