A Week of Jev Game Demos: What They Actually Prove

Games are a good stress test for a decision model, for a boring reason: they force a real-time loop with a clear, checkable outcome. You can't fudge whether the snake hit the wall. In the first weeks after Jev's release, nine small projects showed up doing exactly this — two open reimplementations of Jev itself, two head-to-head matches, one local decision server, and four solo demos that put a single model into a tick-by-tick loop against a game or a simulated task.

None of these prove Jev is "good at games" in any general sense. What they prove, individually, is narrower and more useful: that a typed decision head can run fast enough for a real-time loop, that it can be reimplemented on open weights, and that the interesting engineering problem is almost always the plumbing around the model, not the model call itself. This article rounds up what each of the nine actually shows, with links to the deeper coverage of each cluster.

Key Takeaways

• Two projects reimplement Jev's decision head from scratch on open weights: kev (three sizes, up to 9B) and NanoJev (one 0.6B model), each with its own benchmark suite and its own caveats.
• Two projects are literal head-to-head matches: laya-vs-jev races Jev against a local model at a T-Rex-style runner; OneVOneJev pits it against an opponent in a browser shooter.
• One project is infrastructure, not a game: litjev serves Jev's own /v1/systemone API shape locally, which is what several of the others could run against instead of a hosted key.
• Four projects put Jev into a solo tick-by-tick loop: typesafe-snake, jev-libero, RoboJEV, and jev-drone — ranging from a browser Snake autoplayer to a MuJoCo quadrotor with a three-frequency control split.
• Every single one of these nine is new, small, and self-reported. None has been independently retested by this site; several say so themselves.

The reimplementations: kev and NanoJev

kev (5,163 stars) and NanoJev (2,065 stars) are the two biggest projects in this cluster, and the only two actually rebuilding Jev's decision-head architecture rather than just calling an API. kev ships three model sizes on Qwen3.5 with a published accuracy table (0.852 on its 9B variant) and an explicit note that it's still overconfident on roughly 4% of wrong answers even after calibration. NanoJev is a single 0.6B model that reports beating Jev on some ViZDoom tasks and losing to it on Maze, evaluated on test sets as small as 8 to 10 episodes. Full coverage, including the exact numbers and what each project's own README says about its limits, is in Kev and NanoJev: open reimplementations of a Jev-style decision head.

The duels: laya-vs-jev and OneVOneJev

laya-vs-jev (89 stars) and OneVOneJev (23 stars) are the only two projects in this whole set that actually pit Jev against an opponent — a local MLX model in a dinosaur-runner race, and another agent in a browser 1v1 shooter, respectively. Both are early and thin on independent verification: neither project's own documentation offers a runtime or performance validation beyond its own repository, and OneVOneJev's stated ~9 Hz tick rate is a configured interval, not a measured sustained throughput number. Full breakdown, alongside litjev and the three solo simulation demos, is in Jev vs Jev: duel and arena projects built to stress-test it.

The infrastructure: litjev

litjev (42 stars) doesn't play anything itself — it's a local server that reproduces Jev's own decision endpoint on open-weights models, computing candidate probabilities directly from token log-probabilities rather than generating text. For anyone trying to run several of these other demos without a hosted API key, this is the piece that makes that possible, with the caveat that a locally calibrated probability distribution isn't guaranteed to match hosted Jev's behavior.

The solo demos: Snake, LIBERO, RoboJEV, and a drone

The remaining four projects put Jev into a tick-by-tick decision loop against a fixed task, with no opponent. typesafe-snake (21 stars) is the simplest: one legal-move decision per tick, with illegal moves blocked by code rather than the model. jev-libero (61 stars) and RoboJEV (36 stars) push into robotics simulation — RoboJEV in particular is explicit that Jev sees structured simulator state, not images, and that each task has an independent physical success check the model can't game.

jev-drone (145 stars) is the most architecturally interesting of the four: a MuJoCo quadrotor flying a five-station obstacle course with a clean three-way split between a 500Hz flight controller, a 50Hz safety layer with veto power, and Jev answering tactical questions at roughly 2.5Hz. Its one published result is a single 65-second run, and the author's own framing is narrow — the baseline controller can't attempt certain maneuvers, and Jev supplies that capability, not a general performance gain. Full detail in jev-drone: putting a decision model in the flight loop.

What this cluster actually proves

Set the nine side by side and a pattern emerges that has nothing to do with which one "wins" at its game. The engineering problem every one of these projects solved first was getting state into a form Jev — or a reimplementation of it — could answer a typed question about, fast enough for a real-time loop. jev-drone converts camera buffers to range sectors. RoboJEV hands over structured simulator state instead of pixels. litjev exists purely to serve that typed-answer contract locally. That's the actual finding: the interesting part of "Jev in a game loop" is almost always the state representation and the surrounding control code, not the raw speed of the model call.

What none of these nine prove, individually or together, is that Jev (or its reimplementations) generalizes beyond the narrow task each demo was built for. Every one of them is new, every claim above is self-reported, and several of the authors say so themselves in their own READMEs.

What to do next

1. Read how to evaluate Jev projects honestly before repeating any number from this cluster as fact.
2. If you're building your own real-time loop, start from the state-representation pattern these nine share, not from their benchmark tables.
3. For the trading side of real-time Jev decisions, see jev-trader: a market maker built on Jev and the broader real-time Jev: loops, games and trading.
4. Track new entrants to this cluster on the awesome-jev-projects radar.