Lev

Local JEV

Comment

Lev

Inspiration

"System One" models like Jev make fast, instinctive decisions. They do not write out an answer word by word. For any choice from a fixed list (which tool should the agent call? should the robot arm move now?), they are much faster than normal language models, and often better.

But Jev is closed-source and cloud-only, and its training method is not public. We wanted a System One model that runs on your own hardware, with a training recipe anyone can reproduce.

What it does

You give Lev a situation and a list of possible actions. It returns a probability for each action in about 20 ms.

  • Fast: it picks from the list in one step. It never writes text.
  • Safe output: it can only pick an action from the list. An invalid answer is impossible.
  • Local: It runs completely locally! (we run it on the GX10!)

How we built it

Keep the big model. Swap its last layer.

  • We take an open-weight LLM (Qwen3-8B; the same recipe works for DeepSeek, Kimi or Mistral) and freeze it. We do not train it at all.
  • A normal LLM ends in a next-word layer that scores ~150,000 words. We remove that layer.
  • In its place, we add a small, trained decision head. It outputs one probability for each allowed action, all at once (for example, flap 0.64 · wait 0.36).

Actions run once. Only the state runs live.

  • The state (as text) and each action (e.g. "flap", "wait") go through the same frozen LLM, in separate contexts.
  • Each side gets its own small MLP head: a state head and an action head.
  • The two sides meet only at the end, in a softmax that picks the action that best fits the state.
  • Action vectors are computed once and cached. On each decision, only the state runs. That is why it is fast.

Challenges

  • The standard contrastive loss was broken for this task. When there are only 2–3 choices, it trains on contradictory targets. The model stayed stuck at the exact level the math predicted, no matter how much data we used. We proved why and switched to a plain multiple-choice loss. This fix mattered more than anything else.
  • 93% on tests, 0 pipes in the game. Our data missed the rare frames where one flap decides everything. After that, we judged every model by playing, not by test scores.
  • Vision failed. We tried feeding Lev game screenshots. It could tell that a bird and a pipe were there, but not where. The image pooling step threw away position data.
  • Hardware nondeterminism. Our older AMD accelerators gave slightly different math on each run, and this silently corrupted training. We tracked it down and made the pipeline robust to it.

Accomplishments

  • We built an open Jev-style System One model. We turned an open-weight LLM into Lev, and trained it fully locally on one GX10.
  • Close to Jev, at a fraction of the size. Lev plays almost as well as Jev, and it beats a small autoregressive LLM by a wide margin.

What we learned

  • Tests can lie. The only honest test is live play.
  • The training method matters more than the data. More data only makes a broken method fail faster.
  • The teacher is the ceiling. The student only got strong after the teacher got strong.

What's next

  • Vision that keeps spatial information instead of averaging it away.
  • Bigger open-weights backbones. The recipe works with any model.
  • More games. Tetris groundwork is already in place.
  • Less variance between training runs.

This recipe works with any open-weights model, on any decision you can phrase as multiple choice.

Built With

Share this project:

Updates

Submission history