A support ticket arrives with a broken export and an approaching deadline. Your application needs to pick a queue, estimate the disruption, and decide whether to flag a time constraint. None of those steps requires a paragraph of generated prose. They require answers with a shape your code already understands.

Jev AI, from TypeSafe AI, addresses that part of an application. Its System One interface takes context and questions with defined answer spaces. This guide uses one ticket to show how to choose those answer spaces. For the shorter overview, start with What is Jev AI?

Start with the decision your application will make

Before writing a question, write the next branch of your program. If the next step assigns a queue, your output should be a queue label. If it sorts items by a rubric, you need a score. If it tests a single condition, you need a probability for that condition.

This exercise also exposes tasks that should stay in ordinary code. Checking whether an account exists, comparing a timestamp, or calculating an invoice total does not require semantic judgment. Retrieve those facts directly. Give the model the smaller question that remains, such as whether the customer is describing a billing problem or a broken feature.

Choice: route to a named option

Choice is useful when the application already knows the possible destinations. In our example, the options are product support, billing, and other. The descriptions explain what belongs in each queue; they do more work than vague labels such as “team A” and “team B.”

Spend time on boundaries. A failed payment integration might sound like both a payment issue and a software bug. Decide how your organization handles that overlap, then encode the distinction in the criteria. Adding more labels will not fix an ambiguous policy.

Include a fallback when real requests can fall outside your categories. Without one, an unrelated message still has to compete for an in-scope label. An “other” option gives the surrounding workflow somewhere sensible to send it, although it does not guarantee the model will recognize every unfamiliar case.

Score: define an ordered scale

Score fits an ordered judgment such as relevance or disruption. Here the anchors move from no blocked work, through a delayed task, to stopped operations. An intermediate score is possible; the result is not restricted to selecting one integer label.

Keep the scale about one dimension. A rubric that starts with customer anger, moves to revenue impact, and ends with deadline urgency does not describe a consistent progression. Separate those questions if your application needs all three. You can then decide in code how each factor contributes to priority.

A score is also not a measurement in external units. A disruption score of 1.4 does not mean 1.4 hours lost or a 70% chance of churn. Those interpretations require separate evidence and a different target.

Noul: ask one yes-or-no question

Noul returns the probability of a yes answer. AIJev labels this mode “Yes / No.” For the ticket above, “Does the customer explicitly mention a deadline?” is narrower and easier to audit than “Is this important?”

The narrower question leaves policy decisions visible. Your code can combine a deadline flag with the customer’s service level and verified incident status. It does not need to pretend the model knows an entire escalation policy that was never included in the input.

One ticket, three independent questions

The following original request example follows the official Jev HTTP API. Send it from your server to the provider, using your own credentials. It is an illustrative request, not a recorded model run.

{
  "model": "jev-latest",
  "state": "Our CSV export has failed twice today. We need the report before tomorrow’s team meeting.",
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should investigate this request?",
      "criteria": {
        "product_support": "A feature is broken or behaving unexpectedly",
        "billing": "An invoice, subscription, or payment needs attention",
        "other": "The request does not fit either team or lacks enough context"
      }
    },
    "impact": {
      "type": "score",
      "instructions": "How much does the reported issue interrupt the customer’s work?",
      "criteria": [
        "No work is blocked",
        "One task is delayed",
        "Core operations are stopped"
      ]
    },
    "deadline": {
      "type": "noul",
      "instructions": "Does the customer explicitly mention a deadline?"
    }
  }
}

The named questions evaluate the same state independently. If a later question needs the actual answer to an earlier one, organize that dependency as a later workflow step. Do not assume that naming two questions creates a sequence between them.

For access, authentication, and a complete cURL command, use our Jev API guide. In the free playground, try one decision at a time and change the ticket wording to see how the result responds.

A valid answer can still be the wrong answer

A returned queue label can fit the allowed schema and still send the ticket to the wrong team. That distinction matters when reading claims about type safety or hallucinations. A constrained answer space helps software consume a result; it does not establish that the judgment is correct.

Test examples near your category boundaries, including incomplete messages and requests that belong nowhere. Compare results with reviewed labels. If reviewers disagree, resolve the policy before treating the model’s disagreement as a model problem.

Probability and confidence also need separate interpretations. Choice and Score expose a confidence statistic derived from their distributions. It is not simply the winning option’s probability, and Noul does not expose that same confidence field. See TypeSafe’s confidence documentation before choosing an action threshold.

Where a generative LLM still fits

After routing, you may want a friendly explanation or a draft reply. That is a generation task. Jev does not produce free-form text, so a generative model or a fixed template should handle it. A modern LLM can also support structured outputs; compare the actual quality, latency, and maintenance cost of both approaches instead of assuming every LLM integration requires fragile text parsing.

The useful question is which component should own each step. Keep calculations in code, use a focused model judgment where language is ambiguous, and generate text where the user actually needs text. Our next article develops this into a workflow with confidence-based routing.

Sources and editorial context

This independent article was inspired by unicodeveloper’s “The Ultimate Guide to Jev: The new Frontier AI for faster decisions.” The ticket, request, and design recommendations above are original examples, not reproduced benchmark results.