How to use Jev in game development

What Jev is

The interface: state in, typed decisions out

1. A state. This is any text or JSON that describes the situation. A support ticket, a document, or in our case, a snapshot of your game world.
2. A set of questions. Each question has a fixed type and a fixed set of allowed answers.

{
  "model": "jev-1.13.0",
  "state": {
    "npc": { "role": "guard", "hp": "low", "ammo": "some", "in_cover": false },
    "threats": [ { "id": "player", "distance": "near", "visible": true, "weapon": "shotgun" } ],
    "allies": [ { "id": "guard_2", "hp": "full", "distance": "medium", "can_heal": true } ],
    "objective": "hold the gate",
    "last_action": "shoot",
    "last_action_result": "missed"
  },
  "questions": {
    "action": {
      "type": "choice",
      "instructions": "Pick the best next action for this guard.",
      "criteria": {
        "shoot": "Fire at the visible threat",
        "take_cover": "Move behind the nearest cover",
        "retreat_to_ally": "Fall back toward guard_2 to get healed",
        "call_for_help": "Alert the rest of the squad"
      }
    },
    "danger": {
      "type": "score",
      "instructions": "How dangerous is the guard's situation right now?",
      "criteria": [ "safe", "some risk", "critical" ]
    },
    "should_flee": {
      "type": "noul",
      "instructions": "The guard should give up the objective to survive."
    }
  }
}

{
  "model": "jev-1.13.0",
  "answers": {
    "action": {
      "type": "choice",
      "choice": "retreat_to_ally",
      "probabilities": { "shoot": 0.12, "take_cover": 0.31, "retreat_to_ally": 0.52, "call_for_help": 0.05 },
      "confidence": 0.41
    },
    "danger": {
      "type": "score",
      "score": 1.7,
      "legend": { "0": "safe", "1": "some risk", "2": "critical" },
      "probabilities": { "0": 0.03, "1": 0.24, "2": 0.73 },
      "confidence": 0.71
    },
    "should_flee": { "type": "noul", "noul": 0.38 }
  },
  "usage": { "input_tokens": 412, "output_tokens": 61 }
}

Takeaway: Jev is a decision function. You define the possible answers, it picks one and tells you how sure it is. Your code owns everything else.

How Jev works compared to a normal LLM

Takeaway: LLMs generate new text when the answer is open. Jev picks from known answers when the answer space is closed. In a game, a lot of decisions have a closed answer space.

Other models like Jev

• Zero-shot classifiers based on ModernBERT or similar encoders. Same idea (labels supplied at request time), no instructions, no probabilities you can trust.
• Fine-tuned classifiers (SetFit, a BERT with a head). If you already have labeled data from your game, these are cheaper and often more accurate than Jev on those exact labels. JevBench (opens in a new tab) recorded a run where a small embedding model plus logistic regression beat Jev on one classification task, 93.3% to 83.2%.
• Structured output libraries (Outlines, Instructor). They make any LLM return valid JSON. You keep the LLM's latency and price, and you get no probability.
• Rerankers (Cohere, cross-encoders). They score relevance only. Jev takes free-form questions.

Takeaway: The interface was the invention, and it has already been copied. Jev is still the only one with a calibration claim backed by training. The local clones are worth watching for offline games.

Price, limits, and access

1. Join the waitlist at typesafe.ai (opens in a new tab). Early users reported waits from a few hours to more than a day.
2. Use Vercel AI Gateway (opens in a new tab), which added Jev on September 16 as typesafe-ai/jev. No waitlist, and it supports zero data retention per request.

What it costs in a game loop

Takeaway: For turn-based games, tooling, and a handful of NPCs, Jev costs pennies. For a live game with many concurrent players, the 1,200 requests per minute limit forces you to batch through your own backend, and the bill scales with player count.

How fast and how accurate is it really?

Latency

Accuracy and calibration

Takeaway: Jev is roughly as accurate as a cheap frontier chat model, sometimes better, sometimes clearly worse. There is no universal Jev accuracy. Test it on your own game state before you trust it with anything a player will notice.

How to use Jev in a game

The pattern

Game world (authoritative)
        |
        v
State projection            <- small JSON, only what the decision needs
        |
        v
Legal action list           <- built by your code, preconditions already checked
        |
        v
Jev (Choice / Score / Noul) <- one request, many questions
        |
        v
Validate                    <- still legal? confidence high enough? not stale?
   |          |
   yes        no
   |          v
   |     Fallback (behavior tree, FSM, scripted default)
   v
Command system -> navigation, animation, abilities

• Do not call Jev every frame. Call it when something changes: an action finished, a threat appeared, a target was lost, or a timer expired.
• Run the request off the main thread. Keep executing the previous action while a decision is in flight. TypeSafe Mario even tells the model how many frames the last decision took.
• Always have an answer for the frame where no response arrived.
• Log every state, question, answer, and outcome. You can replay those logs when you change your prompts or your balance.

Use case 1: tactical NPC decisions

Use case 2: turn-based and card games

Use case 3: a director for pacing and difficulty

Use case 4: understanding what the player typed or said

State: "yo can u fix my sword its almost broken"
Choice: repair_item | buy_item | sell_item | ask_about_quest | small_talk | leave

Use case 5: choosing dialogue instead of writing it

Use case 6: procedural generation choices

Use case 7: moderation and player reports

Use case 8: the pipeline, not the game

A C# example for Unity

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public sealed class JevDecisionClient
{
    private static readonly HttpClient Http = new HttpClient();

    // Your server forwards this to api.typesafe.ai and adds the API key.
    private readonly string _endpoint;

    public JevDecisionClient(string endpoint)
    {
        _endpoint = endpoint;
    }

    public sealed class Decision
    {
        public string Action;
        public float ActionConfidence;
        public float Danger;      // 0..(levels-1), weighted
        public float ShouldFlee;  // 0..1
    }

    public async Task<Decision> DecideAsync(
        object stateProjection,
        IReadOnlyDictionary<string, string> legalActions,
        int timeoutMs = 600)
    {
        var body = new
        {
            model = "jev-1.13.0", // pin the version, aliases can move
            state = stateProjection,
            questions = new
            {
                action = new
                {
                    type = "choice",
                    instructions = "Pick the best next action for this guard.",
                    criteria = legalActions
                },
                danger = new
                {
                    type = "score",
                    instructions = "How dangerous is the guard's situation right now?",
                    criteria = new[] { "safe", "some risk", "critical" }
                },
                should_flee = new
                {
                    type = "noul",
                    instructions = "The guard should give up the objective to survive."
                }
            }
        };

        using var cts = new CancellationTokenSource(timeoutMs);
        using var content = new StringContent(
            JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json");

        HttpResponseMessage response;
        try
        {
            response = await Http.PostAsync(_endpoint, content, cts.Token);
        }
        catch (Exception)
        {
            return null; // timeout or network error, caller falls back
        }

        if (!response.IsSuccessStatusCode)
        {
            return null; // 429 and 529 are expected under load, fall back
        }

        var json = JObject.Parse(await response.Content.ReadAsStringAsync());
        var answers = json["answers"];

        return new Decision
        {
            Action = (string)answers["action"]["choice"],
            ActionConfidence = (float)answers["action"]["confidence"],
            Danger = (float)answers["danger"]["score"],
            ShouldFlee = (float)answers["should_flee"]["noul"]
        };
    }
}

public async Task ThinkAsync()
{
    // 1. Build a small projection. Buckets, not raw numbers.
    var state = new
    {
        npc = new { role = "guard", hp = HpBucket(), ammo = AmmoBucket(), in_cover = InCover },
        threats = VisibleThreats(),
        allies = NearbyAllies(),
        objective = CurrentObjective,
        last_action = LastAction,
        last_action_result = LastResult
    };

    // 2. Only offer actions that are legal right now.
    var legal = new Dictionary<string, string>();
    if (HasAmmo && HasLineOfSight)  legal["shoot"] = "Fire at the visible threat";
    if (CoverNearby)                legal["take_cover"] = "Move behind the nearest cover";
    if (HealerAlive)                legal["retreat_to_ally"] = "Fall back toward the healer";
    legal["call_for_help"] = "Alert the rest of the squad";

    // 3. Ask. Keep acting on the previous decision while this is in flight.
    var decision = await _jev.DecideAsync(state, legal);

    // 4. Validate and fall back.
    if (decision == null || !legal.ContainsKey(decision.Action) || decision.ActionConfidence < 0.35f)
    {
        _behaviorTree.RunDefault(); // your existing scripted behavior
        return;
    }

    // 5. Hand the intent to the systems that already know how to do it.
    _commands.Execute(decision.Action);
    _director.ReportDanger(decision.Danger);
}

Takeaway: Start with one NPC role and three to six actions. Keep the state small enough to read in a log. Validate every answer. Have a fallback. Call from your server, never from the client.

Where Jev falls short

• It only reads text. The Doom demo did not see pixels. Someone wrote code to turn the game into text. TypeSafe's launch post says "not on images (yet…)". For now, you need a state serializer.
• It is not deterministic. About 1% of answers changed on a rerun in one test. That rules Jev out of anything that needs a replay to match, like lockstep multiplayer or a speedrun-verifiable AI. Log the decisions, or keep Jev on the server where the result is just another input.
• It is hosted only, and served from the US. No offline mode, no local build, no regional endpoints, no SLA. If your game must work without internet, Jev is not for the shipped game. It can still be for your pipeline.
• English comes first. Other languages work "with lower accuracy" according to the docs. If your NPC states or player chat are in German or Japanese, test before you trust it.
• It is early access. The waitlist, the rate limits, and even the documented context limits have shifted in the first week. Almeida called Jev 1.13 "a low-key research preview" and said more models are coming. Pin your version.
• It is closed and young. No published architecture, no paper, one week of public history, and a $40 million seed round. TypeSafe says the pricing is sustainable and expects it to go down, and also says it cannot prove the price is not subsidized yet.

Is it worth looking into?