The pit wall

01 the hesitation

Should I jump or not.

An open question makes an agent think. A closed one lets it decide.

Watch a language model play a reflex game and you see it hesitate: a paragraph of reasoning about whether to jump, and by the time it finishes, the bird is in the pipe. The problem is not that it is slow to think. It is that it was asked for text, and text can be anything, so it has to work out what to say before it can say it.

Jev is a model that cannot answer with text. You give it the state and a question whose answers you have already listed, and it hands back one of them, with a probability on each and a confidence on the whole. It cannot invent an option. It cannot hedge in prose. It cannot be wrong in shape, only in judgement, which is a smaller way to be wrong.

Decisiveness is the difference. This is not limited to tool calls. It can be generalised to anything.the sentence this post has to earn

02 three moments

Three moments from a race we own. You call it first.

A race simulator we own, run on the real Suzuka centreline: twenty fictional cars, tyre wear with a cliff, a stop that costs twenty-one seconds under green, eleven under a virtual safety car, seven under a safety car, and a field that bunches behind it. Rain is a curve the radar can see coming. Because we own it, the right call at every lap is computable by search: an oracle that knows the physics of the race but not the future, so it prices a flag that might end next lap the way a pit wall has to. Basic strategy for blackjack; an oracle for tyres.

No whole race. Three moments, each a handful of laps around a decision that is close on purpose. Press start and the race runs. Then the flag drops, or the sky does, and you have ten seconds and a call sheet to press a call, which is about what a pit wall gets. Miss it and the car stays out, because that is what happens when nobody speaks. The race pauses on that lap: you see what Jev said in 151 ms, what the oracle said, and where each of the four calls would have put the car. Then let it run to the flag. Run it as often as you like; the traces do not change, but you do.

03 first attempt

Raw numbers, and where they go wrong.

The first version gave Jev what the telemetry gives an engineer: lap, flag, tyre ages, the cars around us with their gaps in seconds, the pit-loss table, the tyre table, the rain forecast as decimals. It had to work out that a car six seconds back and an eleven-second stop means he comes out ahead, and that softs a second a lap quicker over eleven laps pay for that stop. Jev is not a calculator. The model card says so, and the strips below say so louder: on the lap that mattered, the raw state almost never made the box call.

04 second attempt

The radio message.

The second version changed nothing about the model. It changed the state. Code did the sums an engineer does before keying the radio: where we rejoin and behind whom, whether the new set pays for itself before the flag, whether the car behind can undercut us, what the radar says in laps rather than decimals. Jev was shown the sentences. Same question, same four answers. The sheet is one car alone; the race is twenty. What is left to judge is the gap between them, which is exactly what a pit wall is for.

Raw · sound on the decisive lap

32% of 60 races

Derived · sound on the decisive lap

87% of 60 races

Raw · the oracle's exact call

0% of 60 races

Derived · the oracle's exact call

65% of 60 races

How these were recorded. 20 seeded races per situation, every lap of the window (three or four before the decisive lap, three to five after), both states, one request per lap with the pit call and the yes/no questions together. Model jev-latest through @typesafe-ai/sdk 0.6.0, bun 1.4.0, darwin, run by Hetansh Mehta from his own machine on 2026-09-22; latency is end to end from there. The decisive lap's radio message was asked five more times per race: 53 of 60 runs returned the same call every time. Nothing was excluded. A call is sound when its expected outcome is within half a place and 2.5 s of the oracle's best; agreed means the exact same option.

That is the whole System One idea in one move, and it is better shown than said: code calculates, Jev judges. The model did not get smarter between the attempts. The state got honest about what the question was.

05 what decisive means

Fast, typed, and sure enough to act on.

Three things make a decision usable by software rather than by a person reading it. It arrives before the world moves on. It arrives in a shape the code already expects. And it arrives with a number that says how much to trust it, so the code can decide what to do with a shaky one.

The two thresholds are a choice, so here is the choice priced. For a few pairs, how many of the recorded calls on the radio message each zone would take, and how many of the calls acted on were wrong:

At the page's thresholds, 436 of 589 calls would have been acted on and 1 of those was wrong. The price is the other side: 43 of the sixty decisive laps would have gone to a slower model, and most of them were right. Raising the acting threshold to 0.95 makes the acted-on set clean and sends almost everything else for a check. There is no free threshold; there is only the one whose price you have seen.

06 the shape of a decision

How to spot one in your own work.

The pit call is a stand-in. The same shape is everywhere once you look for it, and it has six marks. If a decision has most of them, it is a Jev-shaped decision. If it has two, use something else.

07 where it breaks

What it cannot do, and what the number does not promise.

08 snippets

The request, the derived state, the gate.

Jev is not a smaller chat model. It does not write sentences. You hand it some state and a question whose possible answers you have already written down, and it tells you which one, and how sure it is. That is the whole of it, and it is four steps.

Jev, in four moves.

1. 01Write the state

   The state is everything Jev is allowed to look at. It can be plain text or JSON. The important part is not the format, it is who does the arithmetic: code calculates, Jev judges. Handing over raw lap times and asking it to work out the gap is the version that fails, because it is poor with numbers (07). Handing it the same facts already worked out is the version that works, and it is also just what a race engineer says on the radio.

   state.ts · the radio message

   // code does the sums, so the model only has to make the call
   function radioMessage(s) {
     return `Lap ${s.lap} of 53. ${s.compound}s, ${s.tyreAge} laps old, ${s.lapsToCliff} laps left in them.
   Car behind is ${s.gapBehind}s back and ${s.behindInWindow ? "in the pit window" : "out of range"}.
   Stopping now puts us ${s.gapAfterStop}s ${s.gapAfterStop > 0 ? "ahead of" : "behind"}, in ${s.cleanAir ? "clean air" : "traffic"}.`;
   }

2. 02Ask a typed question

   There are only three kinds of question, and each one fixes the answer space before the model sees it. Choice is one of a list you wrote, up to 255 of them, and you get a probability on every option. Noul is the chance that a statement is true. Score is a rung on a ladder you define, two to ten levels. There is no fourth kind, and there is no free text. Whatever comes back is something you already listed, which is why the result can go straight into code without being parsed or checked.

   questions.ts · the options are the whole answer space

   const questions = {
     // Choice: exactly one of these four comes back, with a probability each
     pit_call: choice("What should the car do this lap?", {
       stay_out:   "no stop this lap",
       box_soft:   "stop for softs",
       box_medium: "stop for mediums",
       box_hard:   "stop for hards",
     }),
     // Noul: how likely is this statement to be true
     undercut: noul("The car behind gains the place if it stops now."),
   };

3. 03Send it

   One request carries the state and every question, and the questions are answered in parallel and independently of each other. Asking a second thing costs you nothing in round trips, and the answer to one cannot drag the other with it. It is an ordinary HTTP call with a bearer key, which means it belongs on a server: there is no key in this page and this site never calls Jev live. Everything you see in the replay was recorded offline and shipped as static JSON.

   pit-call.ts · one call per lap

   // POST https://api.typesafe.ai/v1/systemone, or the SDK, which is this
   import { TypeSafeClient, choice, noul } from "@typesafe-ai/sdk";
   const client = new TypeSafeClient();   // the key comes from the environment, on the server
   
   const res = await client.systemOne({
     model: "jev-latest",
     state: radioMessage(lapState),
     questions,
   });
   
   res.answers.pit_call.choice;      // "box_soft"  - always one of the four you declared
   res.answers.pit_call.confidence;  // 0.84
   res.answers.undercut.noul;        // 0.31, the probability the statement is true

4. 04Decide what to do with the confidence

   This is the part that earns the whole approach, and the part people skip. A number you can act on is only useful if you act on it differently at different values. One threshold splits acting from asking. A second splits asking from handing the problem to something bigger and slower. The thresholds are yours, and picking them is a judgement about what a wrong answer costs you, not something the model can tell you.

   gate.ts · three zones, two thresholds

   const { choice, confidence } = res.answers.pit_call;
   
   if (confidence < 0.55) return escalate(lapState);   // too close to call: ask a reasoning model
   if (confidence < 0.80) return askEngineer(res);       // leaning: put it in front of a person
   return choice;                                        // clear: act on it

09 for your agent

Ask your agent to read this, and it can teach it back.