Jev AI simulation: how a live village runs on Jev decisions

What makes a simulation a Jev AI simulation?

Most AI characters are built from a language model that writes what a character says or does. Jev works differently. TypeSafe describes it as a System One model: software sends it a state and typed questions, and it returns typed answers with probabilities, not paragraphs of text. The model gives up text generation in exchange for answers that code can branch on directly.

That property suits a simulation. A character’s next move is a small, well-scoped judgment: given this situation, which of these actions makes sense? The simulation can ask that question for every character, receive a structured answer, and apply it without parsing prose. Text is still useful for dialogue and narration, so a separate language model handles those jobs.

One decision cycle in Jevs Village

• Code assembles each inhabitant’s situation from world state: where they are, what they need, what is nearby, and what time it is.
• Code enumerates the legal options: actions the rules currently permit, with their targets and any dialogue they involve.
• Relevant memories are retrieved from the inhabitant’s own past and can accompany the options as evidence.
• Jev answers a Choice question over the offered options, returning a probability for each and a confidence value.
• Code validates the chosen action against the world one more time, then commits its effects as a recorded event.
• A separate language model turns committed events into the readable chronicle. Its prose never becomes world state.

Why Jev is given options, not freedom

In this design the model cannot invent a move that the world does not allow. Choosing work does not conjure missing supplies, and an interaction with a neighbour who is not there is not offered. The list of options is the contract between the world and the model.

This is the same division of labour TypeSafe recommends for software in general: keep code in control and give the model narrow, structured decisions. In a simulation it also keeps the story honest. A described action only happens if the world recorded it.

Questions sent together are evaluated in parallel against the same state. The village does not let one question depend on another question’s answer from the same request, which keeps each judgment independent and the request fast.

What a persistent simulation adds

A single decision is a snapshot. A simulation that persists shows what happens next. Jevs Village runs on a server and saves its history, so closing your browser neither pauses nor resets it. The main scheduled decision cycle runs every ten minutes, with activity updates between cycles, and the observer follows the latest recorded state.

Persistence makes small choices matter. Rest changes readiness for later work, supplies pass from one inhabitant to another, and each inhabitant carries a personal record of what they experienced. Later decisions are made in a world that earlier decisions changed.

Animation runs on a different clock from decisions. A figure can walk across the scene without a new model request for every frame, and when a provider is unavailable or the daily allowance is used up, new choices can pause while the last recorded state stays visible.

Other public Jev simulations

Jev launched in early access on 15 September 2026, and developers have already published simulations built on it. Two open-source examples show different designs. Both are independent projects with no affiliation to Jevs Village; the descriptions below follow their own README files as read on 30 September 2026.

• Jev Town is a game engine in which Jev makes fast structured decisions, such as whether to seek someone out or where to wander, while a language model handles conversation, memory, and beliefs. It runs in a browser tab from a local setup with your own model keys.
• Oakhollow is a browser village where Jev chooses each villager’s action from a list of everything that person can do at that moment, and a cheaper text model writes what they say. It runs locally and includes an offline built-in decision mode.
• Jevs Village takes the same core pattern in a different direction: a hosted world with a fixed cast that persists on a server, so you can watch it without installing anything or supplying keys.

What to look for in any Jev simulation

• Who owns the world? Check whether code validates actions or whether generated text can change state.
• Are the options closed? A list of legal actions is easier to inspect than open-ended instructions.
• Do consequences persist? A world that remembers the result of a choice shows more than one that resets.
• Is cost bounded? Every decision and line of dialogue can be a model call, so good simulations cap their spend.
• What stays private? Public views should show outcomes without exposing private memories or hidden reasoning.

Limits of this demonstration

Jevs Village is small on purpose: six inhabitants, a handful of places, and a finite action vocabulary. It is a working demonstration of a design, not a benchmark of Jev’s general performance or a forecast of real societies.

Speed and cost figures for Jev are TypeSafe’s own claims, and the model was in early access at the time of writing. Confidence values describe the shape of an answer distribution and are not a guarantee that a choice is correct. A permitted action can still be a poor one.

Watch a Jev AI simulation run

Open the live village, choose an inhabitant, and follow their public activity alongside the chronicle. Return after a later update and compare what changed. The observer shows public outcomes and summaries; private memory text and sleep-review judgments stay private.