A customer reports that checkout fails every time they pay. Your application needs to assign a team, assess urgency, and decide whether to escalate. The possible teams and actions are already defined; the model needs to choose among them.
Microsoft-Decision-1 targets this kind of work. Microsoft announced it on October 9, 2026, as a decision-scoring model for software workflows. For developers evaluating Jev, it offers another way to classify inputs, score responses, and decide what happens next. Microsoft’s launch article explicitly references JevBench and notes that it added Jev accuracy and calibration comparisons. Source: Microsoft announcement.
This guide draws on official documentation, vendor benchmarks, and independent research. Product information was checked on October 15, 2026.
How Microsoft-Decision-1 works
Microsoft built the model by post-training Qwen3.5-9B for single-pass decision scoring. The application supplies context and predefined alternatives; the model scores the alternatives instead of generating an explanation. An application can use those scores to choose the model, tool, or workflow that handles a request. Source: Foundry Labs.
A correctly formatted answer can still be wrong. Choosing from predefined options saves your application from extracting labels from prose, but you still need to check whether the model chooses accurately.
| Question type | What you ask | Result to use in code |
|---|---|---|
noul | Does this condition hold? | The probability of a yes answer, from 0 to 1 |
choice | Which predefined option applies? | A selected option and option probabilities |
score | Where does this fall on an ordered rubric? | A numerical score and level probabilities |
Microsoft documents these types in its Foundry quickstart. Treat a score as a position on your rubric, not a universal measure of quality.
Where it fits in an application
Four common uses appear in the Foundry Labs overview:
- Ticket classification: assign requests to the appropriate team based on their content.
- Model routing: define the available models and when each should be used, then select one for the request.
- Response evaluation: supply reference material and criteria to assess an answer.
- Agent control: choose whether to continue, retry, stop, or request review.
Consider a support workflow. One question chooses the team, another scores urgency, and a third checks whether key information is missing. Application code can then request clarification or send the ticket to a queue. You can keep the routing rules in code and test them independently.
Use a generative model for drafting the eventual reply. If a decision needs several independent facts, ask separate questions and combine their answers in code. That also makes failures easier to diagnose: an incorrect urgency assessment should not silently change the routing policy.
Pricing and access
Microsoft’s published price is $0.042 per million input tokens, with free output. The launch announcement links to Microsoft Foundry and OpenRouter. Check the current billing terms for your chosen provider before deploying. Source: Microsoft pricing announcement.
At that input rate, 1,000 requests averaging 1,000 billed input tokens each cost $0.042 in input charges. For a fuller cost estimate, account for three components:
- Input charges: context, instructions, and option descriptions.
- Additional API calls: retries and any downstream generation.
- Human review: handling uncertain answers, mistakes, and escalations.
Foundry’s integration uses a provider-specific endpoint:
POST <your-foundry-resource-endpoint>/providers/microsoft/v1/systemoneThe JSON below illustrates a ticket-routing request. Replace the model placeholder with your deployment name. Authenticate separately with Microsoft Entra ID or an API key. The example shows the request format for ticket classification.
{
"model": "<your-deployment-name>",
"state": "Checkout fails with an error whenever I try to pay.",
"questions": {
"team": {
"type": "choice",
"instructions": "Choose the team that should investigate the primary issue.",
"criteria": {
"billing": "Charges, invoices, or refunds without a software failure",
"engineering": "Software errors, failed integrations, or outages",
"support": "Account access or product usage questions",
"needs_review": "Insufficient information to assign a team"
}
}
}
}Validate the returned selection before acting, and handle timeouts and rate limits. Send it to the dedicated decision endpoint. Foundry and a gateway can differ in authentication, endpoint paths, and model identifiers. Follow the Foundry integration guide or the OpenRouter model entry for your chosen route.
How to read the benchmark results
Microsoft’s published benchmark results highlight three points:
- Scope: 36 benchmarks covering nearly 150,000 questions.
- Accuracy: the highest among the models in that comparison.
- Speed: approximately 35 times faster than GPT-6 Sol and 2.5 times faster than H2O-Lightning-4B v1.1, based on median latency.
Those comparisons do not tell you how much faster it might be than Jev. Input length, region, concurrency, network paths, batching, and retries all affect user-visible latency. Likewise, an average accuracy across datasets can hide a weakness on the particular category your business cares about.
Independent research offers another reference point. System One Bench publishes runners and scoring code, describes 16 datasets with 3,250 cases and 4,850 decisions, and includes Microsoft-Decision-1 in its October 12 round. It uses identical state and question bodies through a shared gateway and covers English, French, and Arabic.
The published code is useful when designing your own evaluation, but the results need context: model runs occur on different dates, the gateway adds its own behavior, and dataset averages depend on the scoring rules. Inspect the per-task evidence instead of combining its aggregate scores with Microsoft’s into one ranking.
Microsoft-Decision-1 vs Jev
Both products return decisions that application code can use directly, and they support similar question types. You can compare them on the same workflow, provided you track which model version each result refers to.
| What to compare | Microsoft-Decision-1 | Jev |
|---|---|---|
| Common decision types | noul, choice, score | Noul, Choice, Score |
| Direct API | Microsoft Foundry provider endpoint | TypeSafe POST /v1/systemone |
| Published input price, checked October 15 | $0.042 / million tokens | $0.042 / million tokens |
| Output token price | Free | Free |
| Probabilities and confidence | Microsoft reports calibrated option probabilities | TypeSafe documents probabilities and a separate confidence summary |
| Data processing location | Foundry global or supported data-zone deployment | Confirm TypeSafe’s service and contractual data requirements |
| Production latency | Measure from your actual region and endpoint | Measure with the same workload and concurrency |
| Version control | Record the deployment and returned model | Pin a versioned ID and record the returned model |
Sources: Microsoft deployment documentation, TypeSafe models and pricing, and TypeSafe confidence.
TypeSafe lists Jev 1.14 as available from October 14, alongside 1.13, at the same price. Its documentation distinguishes the preview alias from the stable alias. A result measured on Jev 1.13 is not evidence about 1.14; pin the version you actually intend to ship. Source: current model documentation.
Since the input prices match, the price list alone will not decide which is cheaper to run. Compare actual billed token usage and the cost of incorrect or deferred decisions. Differences in tokenization and how you group questions into requests can change the bill even for the same business task.
There is another migration detail: TypeSafe’s confidence summarizes the probability distribution. It should not be assumed to equal the highest option probability, nor should its threshold be transferred to another provider without validation. Source: confidence semantics.
Your existing infrastructure can help determine where to start:
- Already using Azure? Try Foundry to see whether it fits your identity and deployment processes.
- Already using Jev? Keep your client and validated business rules, and connect the second model for a comparison before deciding whether to migrate.
Evaluate integration effort and model accuracy separately.
Test both models on your own data
Organize the evaluation in five steps:
- Prepare labeled examples. Include ordinary cases, ambiguous inputs, rare categories, and missing information in the languages your users actually use.
- Reserve a test set. Keep some examples out of prompt development for the final evaluation.
- Use the same comparison conditions. Give both models the same questions and business rules.
- Report tuning separately. If you later optimize prompts for each model, distinguish those results from the initial comparison.
- Record the setup. Save the dataset version, model IDs, region, endpoint, and concurrency.
| Measure | Decision it supports |
|---|---|
| Accuracy and per-category errors | Whether important cases are being mishandled |
| Calibration by probability band | Whether a confidence threshold is trustworthy |
| Share of tasks automated at an agreed error rate | How many tasks can be handled without review |
| p50/p95 end-to-end latency, including retries | Whether the workflow meets its response-time target |
| Timeouts, throttling, and invalid responses | How often a request needs a retry or human review |
| Total cost per 1,000 successfully handled items | Whether cheap API calls translate into cheaper operations |
Choose acceptance criteria before inspecting the final results. For example, agree on an acceptable error rate for automatically routed tickets, then compare how much each model can automate at that rate. A model that confidently routes everything can be worse operationally than one that defers ambiguous cases.
Frequently asked questions
Is Microsoft-Decision-1 open source?
Its base model is open-weight Qwen3.5-9B, but the Microsoft model catalog documents a managed offering. We did not find a published Microsoft-Decision-1 checkpoint during this review. Do not plan a self-hosted deployment on the basis of the base model’s license.
Does a probability of 0.9 guarantee a correct decision?
No. Calibration describes behavior over many comparable cases. It is not a correctness guarantee for one prediction. Check errors in each probability band, especially after changing the model, language, options, or input distribution.
Can I replace Jev by changing only the URL?
The request structures are similar, but you still need to check endpoints, credentials, deployment names, response formats, and what each confidence value means. Build a small adapter and regression-test the decisions before changing production traffic.
Which is the better choice?
Choose based on your workload and service requirements. Microsoft’s reported results make it worth testing, but your own evaluation should guide the decision. Existing Jev evaluations also need to match the version you deploy.
Next steps
Try a classification task with known answers through Microsoft Foundry or inspect the OpenRouter entry. To compare the same workflow with Jev, try the Jev API on defapi.
For background, read what System One models and Jev do. If you need to run a model on your own infrastructure, continue with Jev vs Laya. Prices and benchmark results in those articles reflect their stated review dates; check current provider documentation before purchasing.