🔥 looks like Jev just got an open-source alternative.
Laya is a 421M parameter model built for making decisions instead of generating text.
the interesting part:
- runs locally on your laptop or phone
- uses less than 1GB of memory
- supports structured decisions (yes/no, scoring, multiple choice)
- free + open source
in a 30-second Snake benchmark against cloud-based Jev:
Laya: 86.5 decisions/sec, score 46
Jev: 3.2 decisions/sec, score 1
the catch? Laya has a 512–1024 token context window and doesn't generalize as well as Jev without additional tuning.
so we already have an open source alternative to jev... and it's 6-7x faster?!
it's a typed-decision classification system: no chat, no generated text, just fast yes/no, scoring, or choice answers.
> runs in under 1gb of memory
> free on hugging face
> runs on a laptop, or even a phone
there's a real demo where it plays snake live, making a fresh decision every single move.
two honest limits, straight from the project itself:
> only 512-1,024 token context, some cases won't fit
> weaker generalization than jev out of the box
all things Jev in one place
a GitHub collection just dropped packed with hundreds of tools, libraries, and projects built on top of Jev, from teams treating decision-making as its own primitive, separate from language generation entirely.
github.com/AnotiaWang/awe…
An open-source Jev-like model is playing Flappy Bird in real time on a standard CPU.
Laya is a 421M-parameter System-1 decision model running on a 12th-gen Intel i7 with OpenVINO INT8.
No GPU. No token-by-token generation.
It receives the game state and chooses an action in a single forward pass.
LLMs can handle planning and reasoning. Small decision models can provide the fast reflexes.
The best agent stack may not be one giant model.
It may be a slow brain paired with fast reflexes.
Laya is making a pretty strong case for local AI agents.
On a 16GB MacBook Air, local Laya is reportedly making decisions in around 45ms.
Cloud-based Jev is closer to 300ms per decision.
That puts Laya roughly 7 to 11x faster in this Tetris setup.
And the hardware is just a MacBook Air.
No dedicated GPU server.
No API round trips.
No per-token bill.
Laya runs locally, so once the model is on the machine, the inference cost is effectively $0 per decision.
Jev has the opposite tradeoff. You get a cloud model, but every decision depends on the network and the API response coming back.
Tetris makes this painfully obvious.
The agent has to constantly:
see the board → decide → act → see the new state → decide again.
When every move takes hundreds of milliseconds, the delay compounds.
At 45ms, Laya can keep that loop moving much faster.
And there’s another piece I find important:
Laya’s weights are open-source.
That means you’re not just renting access to an AI agent through an API. You can actually run the model yourself, inspect the setup, and build around it locally.
For benchmarks, you can argue about accuracy and scores all day.
But put two agents inside a real-time environment and latency becomes impossible to ignore.
Same Tetris board.
One model waits on the cloud.
The other is sitting on your laptop making decisions almost immediately.
In this particular test, the difference is pretty brutal.
Local inference isn’t just about saving API costs.
Sometimes the biggest advantage is simply that the model is already there when you need it.
Laya just mogged Jev at Tetris.
The interesting part isn’t just that a local model won.
Laya is an open-weights System One model running locally on a 16GB MacBook Air.
Jev, meanwhile, is cloud-based and built with Grok 4.7.
Same game. Same objective. Completely different setup.
And Laya was making decisions about 11x faster.
That matters a lot in games like Tetris.
The model has to constantly look at the board, decide where the next piece should go, and act before the situation changes.
Every bit of latency gets exposed.
With Jev running through the cloud, each decision has network and API overhead.
Laya keeps the entire loop on the machine.
No round trip to a server.
No waiting for another request to come back.
The model sees the board, reasons about the move, and acts locally.
And this is happening on a 16GB MacBook Air.
That’s the part I find more interesting than the Tetris score itself.
We’re getting closer to a world where you don’t necessarily need a massive GPU server sitting somewhere in a data center to run useful AI agents.
A laptop can run an open model locally, interact with an environment, and make decisions fast enough for real-time tasks.
Tetris is obviously a toy environment.
But the underlying test is much more interesting:
How much can local inference accomplish when latency becomes almost irrelevant?
Laya vs Jev is a pretty fun way to show the difference. https://x.com/atomic_chat_hq/status/2102160983409955244/video/1
Benchmarked Laya locally on an ancient laptop:
💻 i5-5200U (2 cores) | 12GB RAM | 5400 RPM HDD
Kept it resident in RAM and got sub-second (~630ms) typed decisions on pure CPU! 🔥
Great open-weight release by @Nandakishorm1. No GPU or cloud LLM needed for fast routing.
#laya #jev
Meet Open JEV DeBERTa V3 Large: a text classification model that doesn't just label, it makes typed decisions. Calibrated, open, and built for real-world trust. Here's why this model is turning heads.
Jev @typesafeai, but with thinking?
TypeLLM can think before producing a type-safe output. It dramatically boosts accuracy without any fine-tuning—surpassing Jev and GPT-5.6 Luna, and coming close to GPT-6 Astra!
Open-source: github.com/TypeLLM/TypeLLM
