If a heuristic fallback can take the moves, is a leaderboard score really Jev playing?

Only for the turns it did not take. The README says the fallback exists so a rate-limited or unreachable API does not stop every game, and that it is flagged in the response — but nothing separates the two on the leaderboard, which is just data/leaderboard.json. Treat a high score as a mixed result until you check the run for fallback flags.

Can Jev pick a move that is not legal?

No, and that is deliberate. Each move sends one choice question whose options are only the currently valid directions, so an illegal direction never appears in the option list. Sliding, merging, spawning, scoring and game-over detection all happen server-side in the hand-written engine in backend/game2048.py rather than anywhere near the model.

Which board encoding actually works best?

Unknown from the README, which is why the editor ships. It offers exponents where 0 is empty and 1 is 2, raw tile values or a text grid, toggleable features such as empty-cell count, max-tile corner, monotonicity, smoothness and mergeable pairs, and move criteria that can be dynamic or plain direction labels. No comparison is published, so measuring it is the exercise.

How do I run it, and what is the key called?

Python 3.10+ and Node 20+. Create a venv, pip install -r requirements.txt, write JEV_API_KEY into a git-ignored .env (TYPESAFE_API_KEY also works), then run python3 -m uvicorn backend.main:app --port 8000. The frontend needs npm install and npm run build only when you have changed UI code. The engine itself is covered by python3 -m pytest backend/test_game2048.py -q.

What exact question does Jev2048 ask Jev each move?

One choice question whose options are only the currently valid directions up, down, left and right, so Jev can never pick an illegal move.

What happens to games if the Jev API is rate-limited?

A local heuristic fallback keeps every game running, and the response is flagged so you know Jev was not the model that decided the move.

What backend does the game expose?

A FastAPI app with endpoints for health, new game, game state and a jev-move, plus format read/update/preview and leaderboard read/save/reset; the 2048 engine is hand-written and covered by tests.

CommunityJev Demos & Experiments

Jev2048 — KyleKreuter

A FastAPI plus React lab where Jev picks each 2048 move through one choice decision per turn, running many games in parallel with a live best score and a browser editor for the exact state payload Jev sees.

See highlights

Open github.com

Stars: 1
Language: TypeScript
Published by: Community
Author: KyleKreuter
Last verified: Oct 2026

KyleKreuter/jev2048

User repository on GitHub

View on GitHub

Let Jev (TypeSafeAI) solve 2048

Forks: 0
Last pushed: Updated Sep 2026

Repo stats from the GitHub API, cached Oct 2026.

This is one of several Jev listings for the same project. The canonical entry is Jev2048 — erhanmeydan.

About this project

TypeSafe's Jev plays 2048 — many games in parallel, live in your browser. Jev2048 is a small AI laboratory: instead of generating text, Jev (a TypeSafe System One decision model) picks the next 2048 move via a single choice decision per turn. The web app runs as many games in parallel as you like, tracks the best score (MAX) live, and lets you experiment with the state format Jev receives — instructions, board encoding, features and choice criteria are all editable in the browser with a live JSON preview.

Quoted from the project's README. Read the full README.

Tagscommunity jevbest catalog-import awesomejev

Works forJev for Classification

Used inJev for Software & DevTools

Languages: TypeScript

Highlights

One choice decision per move with only the legal directions as options, so an illegal move is never on the list; scoring stays in a hand-written engine.
A State Format Editor changes instructions, board encoding, feature toggles and move criteria, with a collapsible JSON preview of the exact request payload.
Parallel games run at once with the best board highlighted and a live MAX score showing score, game number and max tile.
The 2048 engine is hand-written and pytest-covered, and a local heuristic fallback keeps games running when the API rate-limits.

Watch out

A run can stop being a Jev run without saying so loudly: if the API rate-limits or is unreachable a local heuristic takes the move, flagged in the response, so a leaderboard score can mix model and heuristic play. Nothing in the repository separates the two on the leaderboard, which is a single local JSON file, data/leaderboard.json, with no accounts or sharing. The state format is the actual experiment here — exponents, raw values or a text grid, plus toggles for empty cells, max-tile corner, monotonicity, smoothness and mergeable pairs — and the README compares none of the encodings, so which one plays best is left for you to measure. Each move is one request, so long runs mean a request per turn and per-move latency you will feel. Setup needs Python 3.10+ and Node 20+, and the frontend only needs rebuilding after UI changes. Copy reviewed against the repository README on 2026-10-04, not from running it.

Questions about this entry

Short answers drawn from the linked project or page.

More Jev resources like this

laya-server

Self-hosted Docker service and web UI that packages Laya structured-decision inference behind a compatible System One endpoint.