Jev Noul: The Yes/No Question Type

What comes back

The response carries one entry in `answers` per question, under the IDs you sent:

{
  {
  "model": : "jev-1.13.0",
  ,
  "answers": {
    : {
    "is_human_escalation": {
      : {
      "type": : "noul",
      ,
      "noul": : 0.99
    },
    
    },
    "is_repeat_contact": {
      : {
      "type": : "noul",
      ,
      "noul": : 0.93
    }
  },
  
    }
  },
  "usage": {
    : {
    "input_tokens": : 360,
    ,
    "output_tokens": : 39
  }
}
  }
}

Both values are close to 1. The customer asks to talk to a real person, so `is_human_escalation` comes back at 0.99, and "I have asked three times now" matches the `true` description on the second question, which lands at 0.93.

How to read the number

A value near 1 is a strong yes. A value near 0 is a strong no. A value near 0.5 means the model gives yes and no similar probability.

These are the values the TypeSafe docs record for `jev-1.13.0` on the question "Is the customer asking for a human agent?", across six different messages:

The top and bottom of that table are easy. The interesting ones are in the middle. "I need this sorted today, whatever it takes" is urgent but never asks for a person, and lands at 0.26. "Are you a bot?" hints at wanting a human without asking for one, and the model splits almost evenly at 0.40. Those are exactly the messages your threshold has to decide about.

Why a Noul has no confidence value

Choosing a threshold

The threshold lives in your code, not in the model. Most of the time you turn the value into a boolean and branch on it:

wants_human = response.answers[wants_human = response.answers["is_human_escalation"].noul > ].noul > 0.9



if wants_human:
    route_to_agent(ticket)
 wants_human:
    route_to_agent(ticket)
else:
    route_to_bot(ticket):
    route_to_bot(ticket)

Where to put the line depends on what being wrong costs. Use 0.5 when a yes and a no are equally easy to act on. Raise it when acting on a false yes is expensive, like paging someone or issuing a refund. Lower it when missing a true yes is expensive, like failing to flag a safety issue.

A third option is to not decide at all. Send values in the middle to a person and keep both code paths for the clear cases:

YES = YES = 0.8
NO = 
NO = 0.2

wants_human = answers[

wants_human = answers["is_human_escalation"].noul

].noul

if NO < wants_human < YES:
    send_to_review(message)
 NO < wants_human < YES:
    send_to_review(message)
elif wants_human > YES:
    route_to_agent(message)
 wants_human > YES:
    route_to_agent(message)
else:
    route_to_bot(message):
    route_to_bot(message)

The gap between `NO` and `YES` is a dial. If reviewers are seeing too many messages, narrow it. If too many wrong routes are getting through, widen it.

A Noul is not a scale

You could decide in your own code that 0.3 to 0.7 means "some experience", but the model never sees those bands, so nothing in the answer was judged against them. A middle value can mean medium experience or an unclear case, and the spacing between candidates is not something you chose. The Score judges each level description on its own, so every candidate lands on or near a level you wrote.

If you want the degree, write a Score with levels you define.

Writing a good Noul question

• Ask one thing. "Is the customer angry and asking for a refund?" makes the model judge two conditions at once and the number means less. Ask two Nouls and combine them in code.
• Phrase it so a high value means yes. "Does the message contain personal data?" is clear. "Is the message free of personal data?" inverts the meaning, and code that reads it later will get it backwards.
• Remove the middle ground. "Does this candidate have any Python experience?" works well because "any" leaves nothing in between.
• Add criteria only when the boundary is subtle. The instruction alone is enough for most Nouls. Try your questions both ways on your own documents and keep whichever answers better.
• A statement works as well as a question. For "The customer is requesting a refund", a value near 1 means the statement is true.

Noul, Choice or Score

flowchart TD
    A[What shape is the answer?] --> B{Yes or no?}
    B -- Yes --> C[Noul]
    B -- No --> D{Do the answers<br/>have an order?}
    D -- No --> E[Choice]
    D -- Yes --> F{Can you describe<br/>each level?}
    F -- Yes --> G[Score]
    F -- No --> E

use a Choice when the answer is one of several options with no order between them, and a Score when it is a position on a spectrum you can describe in steps. A common mistake is asking three separate Nouls where one Choice would do: if exactly one of the options is true, a Choice gives you the winner plus the full distribution in one answer.

When to use a Noul