How Jev works: the big schema in five boxes

By Christophe Paka · Facts checked on 23 October 2026

Jev is an AI model from TypeSafe that answers questions about your data by picking from answers you wrote, never with text. This page shows how jev works in one drawing. Ask it "which team should take this ticket?" and it sends back billing, with how sure it is.

"When I first saw this I didn't get it," one reader wrote after the launch. There is no chat box and no reply to read. You send data and some questions, and numbers come back. Without a mental model you guess, and you send a huge pile of data and wonder why calls are slow.

Read the figure in five steps, top left to bottom, and you can draw it from memory.

Five steps: your app builds one state and a questions map; one POST to /v1/systemone; Jev runs a Choice, a Score and a Noul in parallel walled lanes; one response returns typed answers; your code acts, confirms or escalates.
Figure 2.1: The big schema. One state, many questions, one call; every answer comes back typed, and your code decides.
Use this diagram on your site

Free to share in your blog post, docs, course or slides, as long as the credit link stays. Paste the code below where the figure should go.

How to read this figure

  1. Box 1: your app builds two things. The state is everything Jev may look at for one decision. Here it is one bundle of named fields: a ticket, an order and a refund policy. The questions sit in a list, each under a name your code picks, its question ID: team, frustration, refund_requested. The model never sees those names.

  2. Box 2: one request carries both. One call to the endpoint, the web address that receives requests, carries the state and every question. The note under the arrow shows two size limits, counted in tokens: the small pieces of text AI services count and bill. Think of them as two walls. The big wall, 64k, holds the whole request. The smaller wall, 32k, holds the state plus any single question. Only the tokens you send in are billed.

  3. Box 3: Jev reads once, judges in lanes. Jev reads the state once and gives each question its own walled lane; no lane sees another. So one question's wording cannot sway the answer to the next. The lanes hold three question types, which TypeSafe names Choice, Score and Noul. A Choice picks one of up to 255 options. A Score places the state on 2 to 10 ordered levels.

  4. Box 4: one response, one answer per ID. A Noul is TypeSafe's word for a yes or no question; it gives the chance that yes is right. Each answer comes back under the ID you chose. The Choice says billing, with probabilities and a confidence. The Score says 1.4: a point between your levels, with a legend that names them. The Noul says 0.95 and has no confidence field. These values are TypeSafe's illustration, not a recorded run.

  5. Box 5: your code decides. A Choice gets one code path per option. A Score is compared with a bar you set, or added to other scores. A Noul becomes a plain if: yes when it is above your bar. Then your code acts on high confidence, asks a person on medium, and escalates on low. For a real recorded call, read the post on the Quick start request and its answers.

Key takeaways

  • Write the full question in its instructions, because the question ID never reaches the model.
  • Ask every question a decision needs in one request, and keep the state small.
  • Log the model field and the input token count on every call.

Worked example: will my request fit through the walls?

TypeSafe's Quick start sends one support ticket with three questions. Use it to size your own calls against the two limits in box 2.

  1. The ticket plus its three questions came to 428 input tokens. At TypeSafe's price, that call cost about $0.000018.
  2. Every lane reads the whole state plus its own question, so the per question limit of 32k binds first. That limit is about 75 times the size of this whole request.
  3. Add a fourth question. There is no separate cap on the number of questions; its wording only adds input tokens to the per request total of 64k.
  4. Go past either limit and the API returns error 400 max_tokens_exceeded.

Result: Questions are cheap to add. A big state is what hits the wall first and slows every lane, so send less state before you reach for anything else.

Questions readers ask

Does the question ID tell the model what to do?

No. TypeSafe's API reference says the ID is not sent to the model and not used in inference. An ID such as is_urgent is for your code. Put the meaning in the instructions, the full wording of the question, and in the criteria, the answers you allow.

Do more questions make a Jev call slower?

Barely, because each question is judged on its own against the same state. TypeSafe's cookbook asked 13 questions about one long article, five runs each way. One call with all 13 took 0.27 s; 13 calls in a row, one question each, took 2.71 s. That is the vendor's own test, so time your own calls. A longer state is what slows a call.

Why is Jev so slow on my request?

Look at the state first. Every lane reads all of it, so a long state slows the whole call and can also lower accuracy. The launch post reports 70 ms to 500 ms a call from the US West Coast. Check the input token count in a test call, then trim the state to what this one decision needs.

Can I trust the probability a Noul gives?

TypeSafe trains Jev so that, over many answers, a probability of 0.8 comes true about 8 times in 10. That is calibration. TypeSafe publishes no calibration numbers of its own and does not promise any single answer is right. So measure it yourself on a few hundred of your own labeled tickets before a rule acts on it alone.

Sources: System One API reference (TypeSafe docs); Primitives overview (TypeSafe docs); Models (TypeSafe docs).

This figure is from Jev Made Crystal Clear, chapter 2.

The chapter builds the idea step by step, with recipes you can follow, a Try it to check yourself, and every source.

Get the book

All diagrams