PlayJev: A Multimodal JEV-Like Model for Small Games

🎮 Gallery

One model, one prompt, ten games. Every tile opens that game on the demo with the model playing; the number under each is its score against the teacher (1.00 = matches the teacher, 0 = random play).

🏆 Scores

16 held-out episodes per game, argmax move, episodes capped at 1500 steps. Random play and the teacher run the same seeds through the same harness. vs teacher is (model - random) / (teacher - random), so 0 is random play and 1.00 is the teacher. In the chart the light bars are behaviour cloning and the first two DAgger rounds, the darkest bar is this release, version 3.

🧭 General Ability

Two held-out sets the training never saw, 200 questions each, asked under the game contract (picture or passage as the state, question as the instruction, answers as the options). This release spends a fifth of every epoch on general image questions and a fifth on text; it beats the base model on MMBench and matches it on MMLU.

How much replay it takes: four runs of 1500 steps from the base model, same budget, a growing share of the batches drawn from general image and text questions. Game agreement is validation agreement with the teachers.

🧠 How It Decides

The model never sees a game's name. It sees the current frame and the list of moves, and it answers with one of them.

The input is the current frame and the list of moves, rendered with the frozen OpenJev prompt. The answer is the single token after Answer:, and the probability over moves is the softmax over the option letters at that position: one forward pass, no sampling, nothing generated. Moves are shuffled in every training sample, so position carries no information. One frame per decision: the vision tower's temporal patch of 2 can carry a previous frame at no extra token cost, and these weights were trained and are served with a single frame.

The demo's single game view is the whole model in one picture: the frame on the left is the only input, the bars are what the forward pass returns, the line below them is how sure it was at every step so far.

from playjev.model import PlayJevModel      # github.com/OmniJev/PlayJev

model = PlayJevModel("OmniJev/PlayJev-0.8B").load()
d = model.decide([frame], options)[0]       # one forward pass, a probability per move
d.choice, d.probs, d.confidence             # the move it takes, the distribution, how sure it is

The prompt, the readout and the option format are built in playjev/model.py, and the demo prints the exact prompt for every game.

🏋️ Training

One program per game (BFS, expectimax, placement search, A* with deadlock pruning, physics search) plays on the game's internal state and labels frames with a soft target. The model clones 863k such frames, then plays two DAgger rounds of 40k frames per game with the teachers relabelling what it visited. Version 3 starts over from the base model on all 1.8M frames those rounds produced, with 60 percent of the batches on game frames, 20 percent on general image questions (A-OKVQA, ScienceQA) and 20 percent on text questions (MMLU auxiliary train, SciQ, ARC), then plays a third round with the same mix. Full fine-tuning, batch 64, learning rate 2e-5 from the base and 1e-5 for a round, fp32 master weights with bf16 autocast. The trainer is playjev/train_sft.py and the whole recipe is scripts/reproduce.sh.

Every record these weights were trained on is in data/: 2,166,984 decisions as JSON lines, each with its episode seed, the move played and the teacher's target. The frames are drawn back from them in a clone of the code repository:

hf download OmniJev/PlayJev-0.8B --include "data/*" --local-dir .
python -m playjev.rebuild data --pages 16

🔭 Open Problems

• 🏃 Motion (Breakout, Mario): one still frame carries no velocity, and these weights get only that one frame.
• 🎯 Single-step precision (Floppy Bird, Tetris): the move that decides the episode is a few hundred frames out of 40k.
• 🔍 Tile digits at 448 px (2048): relabelling cannot help where the digits are unreadable, resolution can.
• ⏱️ Latency: at 83 to 100 ms per step the decision lands one step late, and training on labels shifted one step buys part of it back.

📄 Licence

Apache-2.0, same as the base model. The ten games are other people's work and stay in the code repository under their own licences.