How Jev Works: State, Questions and Calibrated Probabilities

While building our Jev Lab, we asked Jev one question about one customer message, three times, changing a single word each time.

The message: "Hi, I was charged twice for order #4471 last week. I need this sorted before Friday or I'm disputing it with my bank."

Nothing about the message changed. Only the question did. That little table is the best introduction we know to how Jev works: the question is the interface.

What goes into a Jev request?

Two things: the state and the questions.

The state is the evidence Jev reads. It can be a plain string, like the message above, or a small JSON object when the evidence has parts: the latest message, the order status, the customer's plan. When it has parts, questions can point at them by name, so "Is message a complaint?" looks at the message and nothing else.

Each question has an ID for your code, a type (Noul, Choice or Score), an instruction in plain words, and criteria that spell out what each answer means. Here is a complete request, the same shape our lab sends:

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer $TYPESAFE_API_KEY

{
  "state": "Hi, I was charged twice for order #4471 last week...",
  "model": "jev-latest",
  "questions": {
    "is_urgent": {
      "type": "noul",
      "instructions": "Does the sender convey time pressure or a deadline?",
      "criteria": {
        "true": "A deadline, a date, or words like now, today, immediately",
        "false": "No particular urgency"
      }
    }
  }
}

There is no system prompt, no examples block and no formatting instruction. If JSON itself is unfamiliar, our plain-English guide to JSON takes five minutes.

What comes back?

A typed answer for every question, and a usage count. For the three questions in our first lab stage, the reply said: department billing with probability 1 and confidence 1; urgent 0.99; frustration 1.82 on a 0 to 2 scale, with 82% on "angry" and 18% on "irritated", confidence 0.73. It used 512 input tokens and 87 output tokens.

That is all your software needs. No sentence to parse, no chance that this time the model decided to add a friendly preamble.

Why does the wording of a question matter so much?

Because Jev answers exactly what is asked. TypeSafe lists this as its first known limit: scoping words, negations and implied conditions are read at face value.

In the example at the top, the customer never literally asked for a refund. They asked for it to be "sorted" and threatened a bank dispute. So "explicitly ask for their money back?" is fairly answered with 28%, and "want their money back?" with 94%. Neither is a mistake. They are different questions, and the business has to decide which one it means.

Two habits help. Write criteria for every question, so "yes" and "no" are defined, not implied. And test each question on a handful of real examples before relying on it. Our Build mode does this in bulk: paste forty messages, tick your questions, and read the table.

Why can we ask many questions at once?

Questions about the same state are answered in parallel, and each one is blind to the others. That means you can ask speculatively: ask ten things, use the three that matter for this particular message, ignore the rest. TypeSafe calls this speculative fan-out.

It is also cheaper. The state is sent once instead of ten times. In TypeSafe's own test, 13 questions about a long document cost 12.2 times less and ran 10 times faster in one call than in thirteen, and the answers were the same across repeats. The saving is largest when the state is long, because the state is most of what you pay for.

How does confidence work?

Choice and Score answers come with a confidence between 0 and 1. It measures how concentrated the probabilities are. For a three-option Choice at 90%, 6% and 4%, confidence is 0.60; for an even split, it is 0.

TypeSafe's guidance for using it is sensible: below 0.5, send the case to a person; between 0.5 and 0.9, proceed carefully and confirm anything important; above 0.9, act. But the real rule is that each action gets its own threshold, set by the cost of being wrong. Tagging a ticket can run on a lower bar than refunding money.

Noul answers do not carry a separate confidence. The probability is the whole story: 0.5 is maximum doubt.

Which patterns turn Jev's numbers into decisions?

TypeSafe documents four patterns, and together they cover most systems we have seen.

Speculative fan-out asks many questions in one call and lets code pick the relevant answers. Confidence-gated routing uses confidence as a second axis: the answer says where a case goes, the confidence says whether it goes there automatically or via a person. Composite scoring breaks a big judgement into several Scores or Nouls and combines them with weights in code, so "lead quality" becomes fit plus intent plus budget, each visible. Intent routing classifies what someone wants and sends it to the right handler, whether that is a simple rule, a specialist model or a human.

All four share one principle, which TypeSafe states plainly: keep control flow, rules and side effects in code. The model makes judgements. It does not run the process. In our Jev Lab, the seventh stage shows this with an inbox of eight messages: Jev scores them once, and three sliders re-sort the whole inbox as you move them, with zero new model calls.

What are Jev's limits?

TypeSafe also states that customer requests and responses are not used for training.

What does a Jev call cost?

TypeSafe's list price is $42 per billion input tokens, and output tokens are free. The price you pay is almost entirely the length of the state plus the questions.

Our first lab stage, one short customer message and three questions, used 512 input tokens. At list price that is about two thousandths of a cent per message, or roughly $21 for a million messages. Prices change, so check TypeSafe's model page before budgeting, but the order of magnitude is what matters: it makes checking every message affordable, not just a sample.

Speed is similar. TypeSafe cites 150 milliseconds. Measured from our own server, with the network round trip included, single calls took between 0.26 and 0.69 seconds.

Where can we see all of this happen?

In Jev Lab, switch on "Show the JSON in and out" and every request and reply appears in full next to the answers. Stage four has buttons that change one word at a time and keep a history of your runs, so the effect of wording is visible. The Take home page turns whatever you built into ready-to-run code in curl, Python or JavaScript.

If you want to understand the plumbing underneath, API Lab teaches requests and responses from scratch, and How Is It Built? breaks any AI product idea into the pieces you would need, including where a decision model would sit.

Frequently asked questions