The Laya vs Jev Snake Race Measures Network Distance More Than Model Quality

The 29x throughput gap in this video is real, and almost all of it comes from the 300 milliseconds a cloud API call spends on the wire. This is a 31-second greenscreen clip posted by @whitewhoadie (channel name WHOADIE) on 2026-09-21. He stands in the lower right corner, pointing upward, while a dark dashboard fills the top two-thirds of the frame. The dashboard header reads "TYPED DECISION LAB / SNAKE BENCHMARK" with a title of "LAYA × JEV" and a subtitle in Chinese. Two Snake games run side by side: a green board labeled "LAYA / convaiinnovations/laya · 421M" with a "LOCAL / MLX" badge, and a blue board labeled "JEV / TypeSafe · jev-1.13.0" with a "REMOTE / API" badge. Control buttons in Chinese read 开始双机竞速 (start the two-machine race), 停止 (stop), 网络测速 (network speed test), and 导出结果 JSON (export results as JSON). A seed of 2026 and a running clock sit at top right. Burned-in yellow-and-white captions track his speech, and a persistent overlay points to https://github.com/NandhaKishorM/laya. The claim is that an open-source 421M-parameter model running locally beats TypeSafe's cloud-hosted Jev on decision speed.

Both products are real, and the timeline in the audio is slightly off

TypeSafe AI came out of stealth on 2026-09-15 and announced Jev as what it calls a System One model, meaning a model that returns typed values and calibrated probabilities for software to consume rather than generated text. The company was founded by former OpenAI researcher Diogo Almeida along with Erik Gafni and Sasha Sheng, and press coverage of the launch reports a $40 million seed round led by DCVC. TypeSafe's own page lists input pricing at $0.042 per million tokens with output tokens free, and claims end-to-end latency in the 70ms to 500ms range. The name is a reference to Jevons Paradox.

Laya is equally real. The GitHub API reports that NandhaKishorM/laya was created on 2026-09-18 at 04:46 UTC under Apache-2.0, and when I checked it on 2026-09-21 it had 7,305 stars and 623 forks. It is published by Convai Innovations. The README describes three checkpoints: an English base on ModernBERT-large at 421M parameters, a multilingual variant on mmBERT-base at 322M, and a typed-decisions checkpoint also at 421M. The on-screen model label matches the repo exactly.

The audio claim that Laya "has been out the same amount of time" as Jev does not hold. Jev launched publicly on September 15 and the Laya repository was created on September 18, three days later. The looser reading in the transcript, that someone shipped an open-source version as soon as people worked out Jev was a classifier, is consistent with that three-day gap.

The numbers in the caption are a snapshot from the 16-second mark, not the finish

The video description presents a clean scoreboard: "Same Snake game, same typed decisions, 30 seconds: Laya: 86.5 decisions/sec, P50 ~9ms, score 46. Jev: 3.2 decisions/sec, 317ms API round-trip, score 1." I read the on-screen counters across the run and those figures do not describe the 30-second finish.

At the 15.7-second timestamp the dashboard reads Laya score 046, p50 latency 9.2ms, 86.5 decisions per second, 1,362 total decisions, against Jev score 001 with a 317.7ms API round trip. That is where the caption's score of 46 and the 317ms round trip come from. The 3.2 decisions-per-second figure for Jev appears four seconds later. At the 29.8-second frame, near the actual end of the 30-second race, Laya reads score 074 with 2,581 decisions at 86.5 decisions per second, and Jev reads score 003 with a 272.1ms round trip. The real final score is 74 to 3, not 46 to 1.

The direction of the result is unchanged and the throughput ratio holds steady across the whole run. The caption still mislabels a mid-race snapshot as a 30-second result, which matters because the two scores it quotes are the ones a viewer will repeat.

The comparison is local inference against a network round trip

Laya's p50 latency sits at 9.1ms for nearly the entire run, varying by a few tenths of a millisecond. Jev's p50 sits between 300.7ms and 320.4ms, and its per-call round trip bounces between 270.9ms and 394.8ms. The gap is not coming from model architecture alone. The Laya panel is badged LOCAL / MLX, meaning it runs through Apple's MLX framework on the host machine with no network hop. The Jev panel is badged REMOTE / API.

TypeSafe's published latency range of 70ms to 500ms covers what the dashboard measures, so Jev is behaving as advertised. A Snake game asks for a new decision every frame, which is the workload most punished by per-call network overhead. The dashboard even includes a 网络测速 (network speed test) button, which suggests the harness author knew the connection was a variable worth isolating.

Third-party numbers corroborate the shape of the result. Issue #3 on mizorewww/laya-mlx reports cloud Jev at 150ms to 350ms p50 and 2 to 5 moves per second on a Snake reflex loop, against Laya-MLX at 13.42ms and 74.5 moves per second on an M3 Max. The video's Jev side falls inside that range. The video's Laya side, at roughly 9ms and 86.5 decisions per second, runs somewhat faster than laya-mlx's own published 13.42ms and 74.5 moves per second, which points to a different prompt configuration, different hardware, or a shorter decision loop.

The accuracy caveat the video skips

Speed is the only axis the clip measures, and Laya's own documentation is direct about where the base model stands on quality. BENCHMARKS.md states that the base checkpoints sit below the majority-class baseline on the typed-decisions benchmark, scoring 0.362 and 0.342 against a baseline of 0.461, and adds that "all of the capability on this benchmark comes from fine-tuning." The headline 0.766 accuracy that beats Jev's published 0.727 belongs to the fine-tuned typed-decisions checkpoint, evaluated on that benchmark's own training split.

The same file also carries a disclosure worth reading before treating any Laya-vs-Jev chart as head to head: "Jev figures are third-party published, never measured here, no TypeSafe API access." The repository the video links has never called Jev. Laya's published comparison puts its 32.8ms p50 on a Tesla T4 against Jev's third-party-reported 236ms to 276ms, and labels those Jev numbers as indicative rather than measured.

The demo in the video is not in the repo the video links

I pulled the full file tree of NandhaKishorM/laya. There is no Snake game, no dual-race web UI, and no Jev client anywhere in it. The repo contains the laya package, a fine-tuning notebook, a research/ directory with T4 and CPU benchmark scripts and JSON results, and three test files.

The Snake benchmark lives in a separate project, mizorewww/laya-mlx, a native MLX runtime for Laya created on 2026-09-19 under Apache-2.0 with 2,552 stars when I checked. Its benchmark results directory holds more than a dozen snake-prefixed JSON files, and its README reports 75.40 moves per second across 2,400 moves on an M3 Max with optimization enabled. That project explains the LOCAL / MLX badge on screen. It does not ship a side-by-side Jev race UI either, and its README makes no mention of Jev.

The specific dashboard in the video, with its Chinese controls and its live Jev API panel, is a third harness I could not locate. Someone built it on top of laya-mlx and a TypeSafe API key. Without access to that code, the seed, the prompt sent to each model, and the safety layer applied to Laya's moves all remain unknown.

Key Takeaways

The Whisper transcript is one unpunctuated run-on and matches the burned-in captions word for word where they overlap. It states no numbers at all. Every figure in this post comes from the on-screen dashboard or the video description, not the audio.
Jev and Laya are both real. Jev launched 2026-09-15 from TypeSafe AI; the Laya repo was created 2026-09-18, so the "same amount of time" claim is off by three days.
The description's "30 seconds: Laya score 46, Jev score 1" is the reading at 15.7 seconds. The 29.8-second frame shows 74 to 3.
The throughput gap is dominated by the cloud round trip. Laya runs locally through MLX at a 9.1ms p50; Jev spends 270ms to 395ms per call on the network, inside TypeSafe's own published 70ms to 500ms range.
Laya's zero-shot typed-decisions accuracy is 0.362, below the 0.461 majority-class baseline. The 0.766 figure that beats Jev belongs to a fine-tuned checkpoint on that benchmark's training split.
Laya's BENCHMARKS.md states its Jev figures are third-party published and never measured, because the authors had no TypeSafe API access.
The Snake demo is not in the linked repo. It builds on mizorewww/laya-mlx, which the video never credits.
Unverified: the identity and source code of the dual-race dashboard shown on screen, the hardware it ran on, the prompt sent to each model, and whether both sides received identical decision requests. The description's claim of "same typed decisions" cannot be checked without that harness.
Unverified: the video's Laya figures of roughly 9ms p50 and 86.5 decisions per second, which exceed laya-mlx's own published 13.42ms and 74.5 moves per second on an M3 Max.

Resources

NandhaKishorM/laya -- The Apache-2.0 repo the video links, with the Laya package, checkpoints, and fine-tuning notebook. Created 2026-09-18.
Laya BENCHMARKS.md -- The primary source for the accuracy, calibration, and latency numbers, including the disclosure that Jev was never measured directly and that base checkpoints fall below the majority-class baseline.
Introducing System One Models and Jev -- TypeSafe AI's launch post, and the primary source for Jev's 70ms to 500ms latency range and $0.042 per million input tokens pricing.
laya.convaiinnovations.com -- Convai's project site, which states plainly that base models score about 0.35 on typed decisions and that 0.766 comes from fine-tuning.
mizorewww/laya-mlx -- The MLX runtime behind the LOCAL / MLX badge, and the home of the Snake benchmark the video's demo is built on.
laya-mlx issue #3 -- A third-party Snake reflex comparison giving independent figures for cloud Jev, Laya-MLX, and a non-neural baseline.