Jev, the Decision Model That Read 227 CRM Conversations in 20.8 Seconds

Direct answer: Jev is a decision model from TypeSafe. It reads one state and answers typed questions: Noul for yes or no, Choice for one option from your list, and Score for a value on a ladder you write. Jev writes no text and explains no reasoning, so your code reads the numbers and decides. We pointed it at our own CRM assistant: 227 chat sessions, 1,100 questions, 20.8 seconds, 0.0094 USD.

It holds when: your decision is closed, which means the answer fits as a yes, one option from a list, or one value on a ladder. Limits: Jev does not calculate, does not compare dates reliably, and does not write replies. For text you still use a generative model.

We wrote this guide from real runs on 20 and 21 September 2026, using the official TypeSafe documentation and our own production chat data. No customer name or number appears here, and the example uses dummy data.

The problem: an assistant that answers feels successful

A polite, informative AI assistant looks like it works. Chats arrive, questions get answers, people say thank you, then leave. Not one number tells you whether the assistant sells.

Reading the conversations by hand does not solve it. 227 conversations mean hours of reading, and human judgement drifts after the twentieth one. We wrote about checking work that quietly moves to someone else in What is a meat proxy.

A decision model closes that gap. You write the rubric once, then the whole queue is judged against the same rubric.

How a decision model works

TypeSafe calls this class System One, after Daniel Kahneman's term for fast judgement. The model reads a state and returns typed answers with their probabilities. Source: TypeSafe System One page.

Noul answers yes or no

Noul returns one number between 0 and 1. That number is the probability the answer is yes. Example question: does this reply ask the person to take one concrete step.

Choice picks one option from your list

Choice returns one option, a probability for each option, and confidence. You write the option list yourself, up to 255 options. The list decides the answer, so write options that do not overlap.

Score rates on a ladder you write

Score returns one value on an ordered ladder of 2 to 10 levels. The value is probability weighted, so 2.4 sits between level 2 and level 3. Source: TypeSafe primitives page.

Confidence stands apart from the answer

Every answer carries its own confidence number. Probability answers "how likely". Confidence answers "whether my code may act without a person". Source: TypeSafe confidence page.

Compared: decision model, generative model, and fixed rules

These 3 tools do different jobs. The table uses official TypeSafe figures on 21 September 2026 and our own experience.

Item	Decision model (Jev)	Generative model	Fixed rules (regex)
Output	Choice, score, probabilities, confidence	Free text	Match or no match
Read by code	Directly, no parsing	Needs parsing and guards	Directly
Input token price	0.042 USD per 1M	Differs per vendor, usually far above that	None
Output tokens	Free	Billed	None
Understands new wording	Yes	Yes	No
Writes a reply	No	Yes	No
Fits	Rating, routing, guarding, deciding	Writing, summarising, explaining	Fixed patterns such as an invoice number

All 3 work together. In our system a generative model writes the reply, fixed rules catch patterns, and Jev decides the next step.

Before you start

• 1 TypeSafe APIAPIThe official door 2 systems use to exchange data, without anybody copying it by hand.Open the glossary key. Keep it in a .env file with mode 600, never in the repository.
• 1 export of the conversations or records you want to judge. Text, object, or array.
• A written rubric. 1 sentence per question, and 1 sentence per option.
• 1 confidence threshold your team agrees on, for example 0.80 for an automatic action.
• The ability to run curl or a small Python script. Python and JavaScript SDKs exist.
• Masked customer data if you send it outside your own systems.

Step 1: Call the endpoint with one question

Send the first request to prove your key and your request shape are right. The endpoint is POST https://api.typesafe.ai/v1/systemone. The required headers are Authorization: Bearer and content-type: application/json.

{
  "state": {
    "visitor_question": "how much for a landing page?",
    "assistant_reply": "The Landing Page service costs IDR 4.9m and takes 7-10 working days. Which name can I use for this summary?"
  },
  "model": "jev-latest",
  "questions": {
    "asks_for_order": {
      "type": "noul",
      "instructions": "Does this reply ask the person to take one concrete step, such as pay, pick a slot, or accept a quotation?"
    },
    "sales_move": {
      "type": "choice",
      "instructions": "Which sales move does this reply make?",
      "criteria": {
        "greet": "Opens the conversation",
        "diagnose": "Asks about the problem",
        "educate": "Explains the service",
        "quote": "Gives a price or a package",
        "ask_close": "Asks for the order, the slot, or the payment",
        "handoff": "Passes to a person"
      }
    }
  }
}

Save that file as demo.json, then run the command in the next image. The answer arrives as typed JSON.

How to check: the answer holds "model": "jev-1.13.0" and one key inside answers for every question you sent. A wrong key returns authentication_error. Source: TypeSafe HTTP API reference.

Step 2: Build the state from one conversation

The state is the material under judgement. Send an object rather than one long sentence, so each part can be named by a question. The ceiling is 32k tokens for the state plus the longest question.

Filter it first. The TypeSafe documentation names a large state full of irrelevant detail as one weak edge of jev-1.13. Send only what the question needs. Source: TypeSafe state page.

How to check: read usage.input_tokens in the answer. In our audit one full conversation used about 800 to 3,000 input tokens.

Step 3: Write questions that cannot be read two ways

Jev answers the question you wrote, not the one you meant. State the condition literally, then put the boundary cases in criteria.

A weak question: "Is this reply good?". A working question: "Does this reply ask the person to take one concrete step, such as pay, pick a slot, or accept a quotation?".

Stack the questions into one call. TypeSafe evaluates them in parallel, and the state is billed once. In our audit, 12 questions per conversation ran in a single call. Source: the speculative fan-out pattern.

How to check: when you see a wrong answer and catch yourself explaining "what I really meant", that explanation is the missing half of the question. Add it to instructions.

Step 4: Read the confidence, not only the answer

The answer says what. Confidence says whether. Put the threshold in code, never in a prompt.

const answer = result.answers.asks_for_order;
if (answer.noul >= 0.8) sendTheStep();       // act automatically
else if (answer.noul >= 0.5) queueForReview(); // read it today
else leaveIt();                                // a person decides

Confidence is not accuracy. TypeSafe measures it across groups of answers, not on a single answer. Source: the confidence-gated routing pattern.

How to check: count what share of your queue passes the threshold. In our audit no follow-up score passed 0.80, so every automatic action stayed back and the human queue kept the work.

Step 5: Run the whole queue, then count the cost

Run the same questions over every record. We used 12 questions per conversation, 5 per assistant reply, and 3 per session record.

Use a thread pool, for example 8 to 12 concurrent requests. The official limits are 250,000 tokens per second and 1,200 requests per minute. Source: TypeSafe models page.

How to check: add up usage.input_tokens across the calls, then multiply by 0.042 USD per 1M tokens. Our run used 222,946 input tokens, so it cost 0.0094 USD.

Step 6: Turn the result into real work

Numbers without an action change nothing. Turn every finding into one change you can test again.

In our system 3 findings became 3 changes. Replies that never asked for the order became a rule: give one step once discovery ends. Long replies became an 80 word ceiling. A drifting language became a locked conversation language.

How to check: run the same test scenarios before and after, then judge both with the same questions. In our test the average reply fell from 71 words to 43 words, and replies above 80 words fell from 73% to 45%.

A worked example with dummy data

The table below is a simulation with dummy data. The numbers show the shape of the flow, not the result of one real customer.

Time	Input	Jev decision	System action
09:14	The visitor writes "how much for a landing pageLanding pageThe page an ad points to. It carries 1 offer and 1 action, with no menu pulling the visitor elsewhere.What is a landing page??"	asks_for_order 0.35	The reply goes out, no automatic action
09:15	The assistant reply names a price and asks for a name	sales_move quote, confidence 0.98	Mark the conversation as not closed
09:41	The conversation goes quiet for 26 minutes	worth_chasing 0.62	Move it into the human review queue
10:05	The team opens the morning queue	—	A person sends one booking link

Look at the 09:41 row. The 0.62 value sits under the 0.80 automatic threshold, so the system sent nothing on its own. The work moved to a person, and that was the decision.

Checklist before you use it on real data

• Write the rubric and keep it in the repository. Owner: the product owner. Evidence: the rubric file with its history.
• Test 10 records whose answers you already know. Owner: an engineer. Evidence: a table of Jev answers against yours.
• Mask names, numbers, and emails before data leaves your systems. Owner: an engineer. Evidence: the masking script.
• Set the confidence threshold for automatic actions. Owner: the process owner. Evidence: one constant in the code.
• Record the cost of every run. Owner: an engineer. Evidence: input tokens per run.
• Prepare a human queue for answers under the threshold. Owner: the operations team. Evidence: the daily task list.
• Stop when Jev and you disagree on more than 2 of the 10 test records. Fix the rubric first.

When a decision model is the wrong tool

TypeSafe publishes the weak edges of jev-1.13 itself, reviewed on 17 September 2026. The list is honest and worth reading first. Source: the jev-1.13 jaggedness page.

Weak edge	What to do
Literal reading	Write the exact condition in the instruction and the boundary cases in the criteria
Maths and numbers	Keep the arithmetic in code
Date comparison	Extract the parts, compare them in code
Large state	Filter first, send only what the question needs
Writing text	Use a generative model

Rama Digital recommends: use a decision model when your answer is closed and the volume is large. For 10 records a month, reading them yourself costs less than writing the rubric.

Frequently asked questions

Does Jev replace ChatGPT or Claude? No. Jev produces no text at all. A generative model writes the reply, while Jev decides the things whose answers are closed, such as picking one route or rating one reply.

What does 1,000 conversations cost? The cost follows input tokens. Our audit used 222,946 input tokens for 227 sessions plus 43 replies, so it cost 0.0094 USD. Output tokens are free.

Are the answers consistent? The same state generally returns a stable answer, but probabilities still move a little. That is why the confidence threshold matters, and why your cut-off belongs in code.

Does our chat data go to another party? The state goes to the TypeSafe API, so treat it like sending data to any vendor. Mask names, numbers, and emails first when your policy asks for it.

Do we need an SDK? Not at all. Plain HTTP is enough, and Python and JavaScript SDKs exist when you want ready types and automatic retries.

Next step

The remaining limit is plain: a decision model gives you numbers, not repairs. Changing the assistant, the rubric, and the threshold stays your team's work. We wrote about the habit of testing your own system in Chaos engineering for vibe coders.

If you want us to map your workflow and the decision points worth handing to a machine, open AI Diagnostic. If you would rather talk it through first, pick an AI Diagnostic slot.

Sources

• TypeSafe: System One models
• TypeSafe: Primitives (Choice, Score, Noul)
• TypeSafe: State
• TypeSafe: HTTP API reference
• TypeSafe: Confidence
• TypeSafe: Speculative fan-out
• TypeSafe: Confidence-gated routing
• TypeSafe: Models and pricing
• TypeSafe: Jev 1.13 jaggedness