An application routing a support ticket needs a destination it can use, rather than a paragraph about where the ticket might belong. Jev, from TypeSafe, accepts text and returns a defined kind of answer: Choice selects an option, Score evaluates a scale or rubric, and Noul returns a value between zero and one for a yes-or-no statement. Those typed outputs give software a predictable answer format. The interesting question is whether Jev chooses well when people describe similar problems in different ways. Ticket routing gives us a concrete way to explore that.
Ready guideDocumentation checked
In this guide 7 sections
01Fit
Is it for you?
When it helps
Choosing among known destinations when the wording of incoming reports varies
Assessing text against criteria that a human reviewer can also apply
When to choose something else
Writing code, explanations or conversational replies. Those jobs need a suitable generative model
Consequential decisions justified only by a correctly formatted answer or a high confidence value
02Requirements
Before you start
A TypeSafe account for the browser Playground, or API access for an application
Text to evaluate and explicit choices or criteria. Jev does not directly accept images, audio or video
Python 3.10 or newer if you want to use the optional Python SDK, the library that calls the service from Python
Cost and access
The current model reference prices input tokens, the units used to measure submitted text, and lists output tokens as free. Check the chosen model version, rate and limits for your integration. A routing system also costs time when someone must correct a wrong destination or examine a ticket sent to triage, so include that work in your comparison.
TypeSafe’s browser Playground lets you try the model without installing anything locally. Follow the official quickstart, sign in and begin with a synthetic ticket whose contents you can safely submit.
For ticket routing, use Choice with named queues and an explanation of what each one handles. Include triage for reports that are unclear or do not fit. Along with the selected queue, inspect the returned distribution, which describes how the model weighs the available options.
If the browser results are useful enough to justify an integration, create a Python project environment and install the official SDK below. Follow the quickstart’s authentication instructions, keeping credentials out of source files.
The starter has six synthetic support reports, four queue definitions and expected labels written before any model call. Use Jev’s Choice question to make recommendations, then inspect how mistakes differ. Sending an unclear report to a specialist is a different cost from sending a clear report to triage.
Included example files
A small support-service project
Synthetic code, logs, a deliberately stale runbook, and six support tickets. The JavaScript uses Node.js 22+ with no packages or network calls. Product accounts and model access are separate.
Read the queue definitions in request.json and the expected labels in tickets.json. Ticket A is access under these definitions; D belongs in triage because it gives no diagnostic detail. These labels are authored expectations for a tiny teaching set, not evidence about real support traffic.
In the TypeSafe Playground, create the queue Choice using the instructions and criteria below. Supply each ticket’s text as state, one at a time. The copied block is the documented API request shape; if the Playground uses separate fields, enter the corresponding state, question and criteria there. An API integration additionally needs account access and secure authentication from the official quickstart.
Record each actual response’s queue choice and returned model ID in routing/predictions.json, using the example file’s array shape. Keep the full raw response, including probabilities and confidence, separately. The example file contains deliberately imperfect manual labels and must not be presented as Jev output.
Run the local checker against your saved predictions. Read every disagreement against the original queue definitions, especially cases where uncertainty should have led to triage. Reword an unclear definition, rerun the same tickets, and keep both result sets rather than overwriting the first.
Choice request: API body, or equivalent Playground fields
{
"state": "My account is locked after too many password attempts.",
"model": "jev-latest",
"questions": {
"queue": {
"type": "choice",
"instructions": "Route this synthetic support report. Use triage when detail is insufficient or no specialist fits.",
"criteria": {
"access": "Account lockout, sign-in credentials, or permission problems",
"application": "A specific application feature fails despite working access and connectivity",
"network": "An explicitly described DNS, connection, or network failure",
"triage": "Insufficient detail, conflicting evidence, or no fitting specialist"
}
}
}
}
The artifact you are working toward
A small routing trial with an auditable result file
For the manual example only, the local checker must produce the counts below. Your model run may differ. Each prediction needs a unique ticket ID, a valid queue and the actual returned model ID.
All six IDs appear once; missing, duplicate or invalid results are rejected by the checker.
The chosen queue matches the recorded raw response, and the version is the returned model ID rather than only the moving jev-latest alias.
Treat confidence as a statistic derived from the option distribution, not a calibrated probability that your business decision is correct.
Every vague report goes to a specialist+
Inspect whether the triage definition is sufficiently distinct, and test that change against the same ambiguous reports. Do not fix the score by relabeling those reports after seeing the answers.
The tiny trial looks perfect+
Six familiar examples cannot justify automatic routing. Add unseen, representative cases and measure the cost of wrong destinations before connecting the recommendation to real work.
What you can take from this example
You now have request definitions, actual responses and a repeatable comparison, enough to decide what a larger evaluation should test. Keep recommendations separate from execution until your own evidence supports a routing policy.
The included baseline tests and evaluation script were checked locally. The deliberately failing contract tests demonstrate the defects in the starter. No AI product was installed or run for these examples; model responses and reviews will vary.
05Next steps
Go deeper
From a queue name to a delivered ticket
Choosing “network” is only one part of routing. Your application still has to find the current destination for that queue, send the ticket and confirm delivery. The full Jev article follows those steps and compares the whole process with rules or an existing classifier, including cases where the label is sensible but the ticket never arrives.
Choice and Score derive confidence from their output distributions. A high value does not provide a universal probability that this particular answer is correct. Compare confidence with reviewed outcomes from your own tickets before using a threshold for automatic handling. Record or pin the model version so the comparison remains meaningful when models change.
Prefer a rules-based starting point when stable, explicit signals already identify the right queue
An existing classifier or structured-output model
Compare the same labeled reports with a tool you already use before taking on another service
07Evidence and scope
Sources and review
Product behavior is based on the linked official documentation. This walkthrough uses an authored synthetic starter project. Its baseline tests and local checker were checked; no installation, model response or product performance was independently tested for this guide.