What are decision models? Why your service desk needs a governed one
Decision models make fast, typed calls on every ticket. Here is where they fit in the service desk, how Jev and OpenAI's Decisions API compare, and the four controls an enterprise should demand.
Key takeaways
- A decision model reads messy input and returns a typed answer from options you define, with a confidence estimate. It does not write text.
- In the service desk, it fits the many small calls on each ticket: triage, routing, urgency, approvals, sensitive data and answer checks.
- Confidence turns automation into a dial: act when the model is sure, and send close calls to a person.
- Enterprises should demand four things: governance, security, traceability and verification.
- Test any decision model on your own tickets before trusting a demo.
Count the decisions a single ticket triggers before anyone starts working on it. What category is it? How urgent? Which team owns it? Is it a duplicate of an incident that's already open? Did the employee paste something into the chat that should never leave it? Is the knowledge article the AI is about to quote actually relevant?
None of those questions needs an essay for an answer. Each needs a judgment, made quickly and the same way every time, on every ticket. Most service desks hand them to a rules engine, which breaks the first time someone phrases a problem in an unexpected way, or to a large language model, which understands the language but is slow and expensive for a yes-or-no question. Decision models are a third option. The enterprise version just needs a few things the basic version doesn't come with.
What is a decision model?
The category got its name in September 2026, when TypeSafe AI released Jev and called it the first "System One model." Three weeks later it had a second major entrant, when OpenAI opened its Decisions API to all developers in public beta. We cover what Jev is and what it means for employee support separately. The need is older than the name. Service desks have always relied on a layer that makes fast judgments, and they have mostly built it out of rules.
| Rules engine | Large language model | Decision model | |
|---|---|---|---|
| Messy or unexpected wording | Breaks unless a rule anticipated it | Handles it well | Handles it well |
| Speed | Instant | Seconds per call | Under a second; TypeSafe cites 70 to 500 milliseconds for Jev |
| Output | A fixed match | Free text that software must parse | A typed answer from a defined set |
| Says when it's unsure | No, a rule either fires or doesn't | Unreliably, even when asked | Yes, a confidence estimate with every answer |
| Best used for | Exact, stable conditions | Conversation, drafting and reasoning | Repeated judgments at high volume |
The three are not mutually exclusive. Most service desks will run all three, each where it fits.
Where decision models fit in the service desk
Most of the value sits in AI ticket triage and routing, where the same handful of questions gets asked on every request, whether it arrives by chat, email or a phone call.
| The decision | Type of answer | Illustrative answer | What happens next |
|---|---|---|---|
| What category is this ticket? | Pick one option | Network (0.91) | Routes to the network queue |
| How urgent is it? | Score on a scale | 2 of 3 | Sets priority and starts the right SLA clock |
| Is it a duplicate of an open incident? | Yes probability | 0.87 | Links to the parent incident |
| Does the request need manager approval? | Yes probability | 0.96 | Starts the approval workflow |
| Does the message contain sensitive data? | Detection | Employee ID found | Redacted before anything leaves |
| Does the knowledge article support the suggested answer? | Verification | Contradicted | Answer held back for review |
Illustrative values for explanation only.
The numbers in brackets are where this gets useful. AI ticket classification has been around for years. What changes is that each answer now comes with how sure the model is, and the service desk decides what to do with that.
A password reset can run on a lower bar than a request for access to payroll data. Where those lines sit is a policy decision, and it belongs to the service desk, not the model vendor.
Jev and OpenAI's Decisions API: two decision models, three weeks apart
The fastest way to see where this category is heading is to put its two best-known products side by side.
| TypeSafe Jev | OpenAI Decisions API | |
|---|---|---|
| Status | Early access since September 15, 2026 | Public beta since October 6, 2026 |
| Input | Text only | Text and images |
| Answer types | Choice, score and yes probability, with confidence | Choice with confidence, score and yes probability |
| Input price | $0.042 per million tokens | $0.10 per million tokens |
| Output price | Free | Free |
| Underlying model | A purpose-built decision model | GPT-6 Luna |
Sources: TypeSafe AI documentation; OpenAI API changelog and public beta announcement, October 6, 2026.
The cost difference between the two is real but small. The difference between either of them and a general-purpose language model is not.
Two providers shipped nearly the same interface, with prices a few cents apart, within a month. That is what a commodity looks like early on. For a service desk, it means the model inside is becoming the interchangeable part. What isn't interchangeable is everything around it.
Why the enterprise version has to be different
Whichever model you choose, it is a component. Putting it into employee support means pointing it at personal data, retrieved knowledge and actions that change systems. Four requirements separate a model that demos well from one an enterprise can run.
Governed
The service desk sets the thresholds, the review paths and the questions themselves, workflow by workflow. Confidence is visible on every decision, so close calls can be found and audited later. The model also shouldn't change underneath you. TypeSafe's own docs note that its jev-latest alias moves when a new version ships, so thresholds tuned against one version can drift unless the version is pinned. Governance like this works best when it is built in rather than bolted on.
Secure
The 2025 OWASP Top 10 for LLM Applications ranks prompt injection first and sensitive information disclosure second. Decision models are not exempt. TypeSafe documents that Jev doesn't treat its input as hostile by default, and that text written to steer the model can move its answer. In a service desk, that means sensitive data has to be found before content leaves, and retrieved content has to be screened for hidden instructions before any model reads it.
Traceable
When a model pulls out a value, such as an asset tag, a date or an error code, someone should be able to see exactly which words it came from. When the system generates a value rather than reading it, that should be marked. Otherwise nobody can tell a read value from an invented one when it matters, which is usually during an audit or an incident review.
Verifiable
An answer is only as useful as its support. Before a suggested fix reaches an employee, it should be checked against the sources it claims to come from. That is a check on the answer, not a reason to rewrite your knowledge base for AI. Your content is what it is, and it is the system's job to use it well, which is a theme we picked up in what actually breaks AI answers.
How Rezolve.ai is building this: Clocked by Rezolve.ai
Clocked by Rezolve.ai is our answer to those four requirements: a set of decision and extraction capabilities built for enterprise employee support, where each control is part of the request rather than a separate project.
The clearest way to explain it is to follow one request. An employee in Microsoft Teams pastes a screenshot of a VPN error, adds their employee ID and asks why they keep getting disconnected. Before anything else happens, Protect finds the employee ID and decides what is allowed to leave. Fill reads the screenshot natively, with no separate OCR step, pulls out the error code and decides category and urgency in the same schema, marking any value it had to generate rather than read. Decide answers the routing questions on the message with a probability for each, so a confident "network issue" routes itself and a close call waits for an analyst. When the agent retrieves knowledge articles to suggest a fix, Guard checks them for content trying to take control, and Verify checks the suggested answer against those articles before the employee sees it. If the fix involves running a script, Inspect reads what that script actually does before anyone approves it.
Every step returns typed output the service desk can inspect, and every threshold is set by the team running it. Clocked works with text and images across languages. One caveat applies to it as much as to any model: probabilities are signals, not guarantees, so accuracy should be evaluated on your own content before thresholds go live.
Clocked comes from the team behind Rezolve.ai's agentic service desk, which received the highest score of 10 products evaluated in two of three Use Cases, AI for End-User Self-Service and AI for IT Agents, in the 2026 Gartner® Critical Capabilities for AI Applications in IT Service Management.
How to evaluate any decision model
Whether you build on a decision model directly or get one inside a service desk product, the evaluation looks the same.
- Test on your own tickets. Demos use short, clean inputs. Pull a few hundred real tickets, including the badly written ones, and compare the model's answers to what your analysts decided.
- Check calibration, not just accuracy. When the model says 0.9, it should be right about nine times in ten across a batch. TypeSafe itself notes that calibration holds across groups of predictions, not for any single answer.
- Set thresholds per workflow. Decide where it acts alone, where a person confirms and where it always escalates, then revisit those lines as you learn.
- Try to break it. Write tickets that argue for their own priority, mix languages and attach screenshots. Watch what moves.
- Keep exact logic in code. Dates, counts, SLA math and policy rules belong in deterministic code. Let the model handle the judgment around them.
- Read the data terms. Find out where requests are processed, how long they are kept, whether they are used for training and whether the model version can be pinned.
A rules engine tells you what it was told. A language model tells you what sounds right. A decision model tells you what it thinks and how sure it is, and that last part is what lets an enterprise decide where people stay in the loop. Choosing a decision model is really choosing who controls that line.
Last updated on October 9, 2026
Get summary with:
See the agentic service desk in action
Watch Rezolve.ai autonomously resolve real IT and HR tickets: governed, auditable, glass-box.
Frequently asked questions
What is a decision model in AI?
A decision model is an AI model that reads unstructured input and returns a typed answer from options defined in advance, such as a category, a score or a yes probability, along with a confidence estimate. It is built for software to act on, not for people to read.
How is a decision model different from an LLM?
An LLM generates text one token at a time, which suits conversation and reasoning. A decision model returns structured answers from a fixed set, usually in under a second and at a much lower cost per decision, and it reports how confident it is. Most service desks will use both.
Can a decision model replace ticket routing rules?
Partly. Keep rules for exact, stable conditions, such as a named VIP list or a specific asset type. Use a decision model where the language varies too much for rules to keep up, and combine the two in code so each handles what it does best.
How do confidence thresholds work in AI ticket triage?
Each decision comes with a confidence estimate. The service desk sets bands per workflow: act automatically above one level, ask an analyst to confirm in the middle, and route to a person below it. Thresholds should be tested on real tickets and revisited as volumes and categories change.
Is it safe to use decision models with employee data?
It can be, with the right controls. Check where requests are processed and how long they are kept, remove sensitive data before content leaves, screen retrieved content for injected instructions, and keep a person in the loop for low-confidence decisions.
Is OpenAI's Decisions API a decision model?
It does the same job. OpenAI's Decisions API, in public beta since October 6, 2026, returns typed answers, such as a probability, a choice with confidence or a score, instead of text. It runs on GPT-6 Luna, OpenAI's smallest current model, while TypeSafe's Jev is built as a separate decision model from the ground up.
What is Clocked by Rezolve.ai?
Clocked by Rezolve.ai is a set of decision and extraction capabilities Rezolve.ai is building for enterprise employee support. It turns text and images into typed decisions, extracted values with their sources, sensitive data checks, prompt injection checks, script inspection and answer verification, with thresholds set by the service desk.
