Jev Flight School is a small experiment in AI decision-making. Jev controls a Flappy Bird game by choosing one of two actions, flap or coast, over and over again.
Jev is TypeSafe's first System One model. It reads natural-language or structured text, then returns a typed judgment with probabilities. It does not generate prose, code, images, or an explanation of its reasoning.
This game uses a Choice question. The only possible answers are:
flap
coast
Jev returns the selected action, a probability for each action, and confidence. The game can use that response directly without parsing a paragraph or asking the model to format JSON correctly.
I got access to Jev and wanted to understand where a decision model fits next to an LLM.
An LLM is useful when an application needs language, code, research, or multi-step reasoning. Many software loops need something smaller: look at the current state, choose from known actions, expose uncertainty, and hand control back to code.
Flappy Bird makes that difference visible. The model cannot hide behind a polished answer. Each judgment immediately changes the world, and a bad sequence ends the run.
This project explores a simple division of labor:
| LLM | Jev in this experiment | |
|---|---|---|
| Main output | Generated text or code | One typed choice with probabilities |
| Role in software | Produce or reason through an answer | Make a bounded judgment inside a code loop |
| Available actions | Open-ended | Defined by the application |
| Uncertainty | Often handled through prompting or extra logic | Returned with the decision |
| Game use | Could explain how to play or write a controller | Chooses the next move directly |
This is not a benchmark proving that one model class is better. It is a working example of a different interface between AI and software.
- The game measures the bird's height, vertical speed, and position relative to the next pipe.
- The physics engine projects
flapandcoast320 milliseconds forward. - Jev receives the current state and a text description of both projections.
- Jev chooses an action.
- The game applies that action for 160 milliseconds and asks again.
The game pauses while the request is in flight, so internet latency does not move the bird. The forecast dots are only a visualization for the player; Jev receives text and structured values, not the canvas image.
There is no safety controller. If Jev returns a bad action, the game still applies it.
- Jev's flap and coast probabilities
- The action applied to the bird
- Request latency
- Input-token usage and estimated API cost
- The exact state description sent for the decision
- A decision history for the current flight
- A human mode using Space or tap, with no API requests
The first controller sent mostly raw coordinates. It crashed before the first pipe after 14 decisions.
The revised controller also describes the situation in plain terms, such as "above the opening and still rising," and includes a short physics forecast for each action. On the saved seed-42 run, it cleared five pipes in 67 decisions.
That run used 43,003 input tokens. At Jev 1.13's listed price of $0.042 per million input tokens, the model cost was about $0.0018. It is one development run, not a general performance claim. Both traces are available in research/.
game.mjscontains deterministic physics, observations, and the Jev Choice request.public/contains the Canvas game and interface.server.mjsruns the local Node version.worker.mjsruns the hosted version and keeps the API key server-side.game.test.mjsandworker.test.mjsverify physics, decision handling, session isolation, and failure behavior.
The browser never receives the TypeSafe API key. Hosted flight state is stored in a signed, HttpOnly cookie. A failed model request pauses the flight instead of silently choosing an action.
You need Node.js 22+ and a TypeSafe API key.
cp .env.example .env
# Add TYPESAFE_API_KEY to .env
npm startOpen http://localhost:3218.
Run the checks with:
npm test
npm run build
npm run test:hostingnpm run check:jev makes paid API calls and reruns the saved flight probe. .env is ignored by Git.
- Jev 1.13 accepts text, JSON objects, and arrays of text. It does not accept images, audio, or video.
- The physics forecasts are calculated by code. Jev chooses between them.
- The simulation is decision-paced rather than 60 Hz model control.
- Probabilities describe uncertainty across predictions; they do not guarantee that one move or one flight will succeed.
- The prompt and state shape were developed for this game and should not be treated as a universal controller.