Microsoft-Decision-1 pricing (2026): $0.042 per million tokens, explained

What Microsoft-Decision-1 actually is

Microsoft-Decision-1 is a small model that does not write text. You give it a situation and a fixed set of answer options, and it returns a calibrated probability for each option. Microsoft launched it on October 9, 2026, in Microsoft Foundry and through OpenRouter, with a launch post by Satya Nadella on X.

It belongs to a fast-growing category of decision models, alongside TypeSafe Jev, Cloudflare Clef and Strands Decider. Microsoft built it by post-training Alibaba's open-weight Qwen3.5-9B (see Qwen pricing for the family), and says it will "soon rebase it on other models, including Microsoft AI (MAI) and OpenAI."

The quick facts from the Foundry model card:

• Lifecycle: "Generally available (GA)", version 1, sold "Direct from Azure"
• Context window: 32,768 tokens
• Input / output: text in, JSON out. No explanations or rationales
• Question types: yes/no, multiple choice, rating, and rubric-based grading
• Weights: not released. The Hugging Face path returns a 404

I build integrations and APIs for a living, and this shape is familiar. Most of what an AI support agent does all day is not writing. It is answering small questions: is this billing or technical, is it urgent, is the customer angry, is the draft safe to send. A model that only answers those questions, quickly and with a confidence score, is useful. The price question is whether that usefulness is cheap enough to call on every single ticket.

How much does Microsoft-Decision-1 cost?

Microsoft states it in one sentence in the launch post: "Input tokens cost $0.042 USD per million tokens. Output tokens are free."

Free output matters more than it looks. With an LLM, a classification answer costs you output tokens, and output is usually priced 5x input or more. Here, the answer is free, so the bill is driven entirely by how much text you send.

Where you pay

There are two ways in, and they price the same:

1. Microsoft Foundry. Billed through your Azure subscription. Microsoft's Learn docs say models sold by Azure are "billed through your Azure subscription, covered by Azure service-level agreements, and supported by Microsoft" (Microsoft Learn).
2. OpenRouter. Same $0.042 input and $0 output, served by Azure behind the scenes. OpenRouter's page shows a weighted average paid of $0.04152 per million input tokens over the first few days (OpenRouter).

If your company already runs on Azure, or already buys Azure OpenAI models, Foundry is the obvious path: one invoice, existing procurement, and the Azure SLA. OpenRouter is the quicker path for a prototype, since you skip the Azure setup entirely.

Microsoft-Decision-1 vs Jev vs Clef vs OpenAI: price per token

Microsoft's launch post compares cost only against GPT-6 Sol. That is where the "200 times less expensive" line comes from. It is a fair number, but it compares a narrow decision model to a flagship general model, which is like comparing a calculator's price to a laptop's.

The comparison that matters is against the other decision models. Here are the live rate cards as of October 11, 2026:

Three things jump out:

• It ties Jev to the cent. Microsoft matched Jev pricing exactly, which is not an accident in a market where Jev is the default.
• It undercuts OpenAI by 2.4x. OpenAI's Decisions API went into public beta on October 6 at $0.10 per million input tokens.
• It is no longer the cheapest. Cloudflare cut Clef-flash to $0.038, with a smaller 24,576-token context. That is about 10% less than Microsoft-Decision-1. My earlier Clef pricing breakdown covers how Workers AI bills it.

The developer crowd noticed the missing comparison right away. The top reply under Nadella's launch post asked the obvious question:

"How is Jev not ranked? That's literally the #1 model people are going to compare this to."

Shayan (@ImSh4yy), X

Microsoft later updated the post to add Jev to its accuracy and calibration tables, but the cost chart still only shows GPT-6 Sol. On Hacker News, one commenter put the price critique bluntly:

"Looks like yet another non-price-competitive Jev competitor. Microsoft only compares the price of theirs to GPT Sol(!), not GPT Terra, or GPT Luna (which is what OpenAI's Jev wannabe is based on), and certainly not Jev (4/10 the cost of Luna). I can't remember when a new product created So many competitors so quickly. What is very clear is that everyone is saying "Doh!", slapping themselves on the forehead, and scrambling to get a slice of this obvious-in-retrospect massive pie. What no-one appears to have done yet is to come close to Jev on pricing!"

HarHarVeryFunny, Hacker News

That comment was written before the price was widely spotted. In fact, Microsoft did come close to Jev on pricing: it matched it.

Per token is not per decision

Here is the twist that makes rate cards less useful than they look. Each model tokenizes and formats your request differently, so the same ticket can cost a different number of tokens on each one. The only hands-on comparison I found came from a Hacker News user who ran Microsoft-Decision-1 against Jev in their own test suite:

"In my minimal suite it was cheaper (by 0.72x) but higher latency (283ms vs 369ms p50) than Jev. Results were very comparable across all scenarios I measure, first of these that I have tested that actually justifies its existence as a commercial release. Qwen tunes are nice and all but either price or performance makes each example I have tested not viable unless you are able to cheaply self-host and fine-tune further."

Topfi, Hacker News

Same rate card, different real bill. That is one person's suite, not a benchmark, but it is the right instinct: run your own tickets through both and compare the invoice, not the price page.

What a decision really costs

Since output is free, the only number you need is how many input tokens each call carries. That is the ticket text, plus your questions and their option descriptions.

Microsoft's own estimate is that classifying one million texts costs about $11 on Microsoft-Decision-1 versus about $2,434 on GPT-6 Sol. Working backwards at $0.042 per million tokens, that implies about 260 input tokens per text in their test. Support tickets are usually longer than that, and a long thread with order history attached can run to several thousand tokens.

Here is what a support team actually pays, assuming two decision calls per ticket (say, one for routing and one for "safe to auto-reply?"):

Clef figures are at list price, before Cloudflare's daily free allowance. Either way, a 100,000-ticket queue costs less than $20 a month to score. At that point the model is not your cost. The engineering time to build, test and maintain the pipeline around it is.

One more lever: a single call can carry several named questions about the same ticket (OpenRouter). If you ask "which team", "how urgent" and "is it spam" in one request, you pay for the ticket text once instead of three times. Bundling is the single easiest way to cut the bill, and the cheapest piece of LLM optimization you will ever do.

Estimate your own Microsoft-Decision-1 costs

Plug in your volume, average tokens per call, and how many calls you make per ticket. The calculator prices all five hosted decision models at their list rates.

Pricing gotchas to watch for

The rate card is simple. The fine print around it is thin, and that is the gotcha. A few things to check before you build on it:

• It is not on Azure's pricing page yet. The catalog's "View pricing" link lands on the Foundry Models pricing page, which lists other Microsoft models but no Microsoft-Decision-1 row as of October 11. The $0.042 figure comes from the launch post and OpenRouter.
• No published regional or provisioned rates. On the same Azure page, Microsoft's MAI-DS-R1 costs 1.1x more on Regional deployments than on Global. Nothing confirms whether Microsoft-Decision-1 follows the same pattern, so check before you pick a data-residency option.
• No region list or quotas. The model is missing from Microsoft's region availability page, and rate limits are not documented.
• Your chat SDK will not work. On OpenRouter it runs on a separate Decisions endpoint, and "chat completions SDKs will not work with it." At launch, one developer who deployed it in Foundry wrote that "it doesn't say what to POST or what to expect back" (wkcheng, Hacker News). Budget integration time.
• The weights change under you. OpenRouter notes that "weights are updated continually while the API shape stays the same." If you set a confidence threshold like "auto-route above 0.85", re-check it after updates.
• The 32,768-token cap. Long email threads with attachments pasted in can exceed it. You will need to trim, and trimming logic is engineering time too.

None of these are dealbreakers. They are the normal state of a model that is two days old. But "GA" on the model card and "not on the pricing page" on Azure is a combination worth a quick email to your Azure rep before you commit volume.

Is it accurate enough to justify the price?

Price only matters if the answers are right. Microsoft's numbers are strong, but they are Microsoft's own tests. In its 36-benchmark comparison (147,137 questions), Microsoft reports 83.5% average accuracy, ahead of Jev 1.13.0 at 82.3% and GPT-6 Luna Decisions at 79.4%. It ranks third on calibration, at 92.2 against Jev's 93.7.

Source: Microsoft launch post, all figures Microsoft-run. Microsoft's latency was measured through Foundry in the same region; others are from JevBench.

Two independent checks are worth knowing. OpenRouter's own measurement shows a p50 latency of 0.19 seconds, slower than Microsoft's 85 ms figure, which makes sense since it includes network hops. And Microsoft-Decision-1 does not yet appear on the community-run Jev Decision Index leaderboard, where Perplexity's decider and Jev hold the top two spots.

If you threshold on probabilities, calibration matters more than accuracy. One Hacker News user summed up that trade-off: "if you need calibration better use JEV" (nowittyusername). The gap is 1.5 points, which is small, but it is in Jev's favor.

Microsoft also shared internal results: its Microsoft Copilot team found the model "competitive with GPT5.6 Luna and 100 times faster," and Xbox Research found it "200 times less expensive" than GPT-6 Sol on over 10,000 feedback items. Useful signals, but again self-reported. If you are weighing it against a small general model, my GPT-5.6 Luna write-up has that side.

Is Microsoft-Decision-1 worth it for support teams?

At $0.042 per million tokens, the model's price stops being a factor. The real question is whether you want to build the system around it.

What it gives you is the sorting step of ticket triage: which queue, how urgent, is it spam, is this AI draft safe to send.

What you still need to build is everything around it: pulling the ticket through your helpdesk API, writing the questions (these triage prompt templates are a decent start), setting the thresholds, routing based on the answer, and then actually resolving the ticket.

That last step is the expensive one, and it is where I have seen the real errors live. In one real-traffic trial on an e-commerce Zendesk inbox, eesel's triage hit 93% accuracy and caught 100% of spam, while only 12% of the AI drafts were sent with no edits. Sorting is the easy half. Answering well is the hard half.

The probability score is still the most useful thing about these models. A CX lead running 7,000 tickets a month put the requirement plainly on a sales call with eesel:

"I need an AI who is only handling the tickets that it's confident to handle and all the other ones, leave them alone."

A calibrated probability is exactly the tool for that. So my verdict:

• Use Microsoft-Decision-1 if you have engineers, you already run on Azure, and you want triage, routing or guardrail checks inside your own product or pipeline.
• Use Jev or Clef-flash if you are cost-optimizing at huge volume and are not tied to Azure. The price gap is small, so test accuracy on your own data first.
• Skip building it if what you actually want is tickets sorted and answered inside your helpdesk. That is a product, not a model call, and you can automate ticket triage without writing code. See my roundup of the best AI for ticket triage.

eesel for the decision and what comes after it

If you are pricing Microsoft-Decision-1 because you want tickets routed, tagged and prioritized, consider skipping the build. eesel is an AI teammate for your helpdesk. It plugs into Zendesk, Freshdesk, Gorgias and others in a few minutes, learns from your past tickets and help center, and makes the same Zendesk triage and escalation calls a decision model would. Then it writes the reply, updates the order, or hands off to a human when it is not confident.

Pricing is per ticket, not per token. eesel's plans start at $299 a month for 500 credits, where one ticket or one chat is one credit, no matter how many steps the agent takes inside it. At 5,000 credits it is $1,749 a month, or about 35 cents per ticket. That is far more than a decision call, because it includes the work, not just the sorting. Compared with a human agent's cost per ticket, it is a different story; my AI vs human cost breakdown runs those numbers, and Zendesk AI pricing shows what the native add-on route costs. Before going live, you can simulate the agent against your historical tickets to see what it would have done, which is how I would test any of these models anyway.

If you are a developer, the eesel CLI gives you the same teammate from a terminal. npx @eesel/cli init chat-bubble --site <url> sets up a workspace, eesel integrations connects your helpdesk, eesel automations wires up routing rules, and eesel approvals lets you approve or deny actions the agent held for review. It is the same agent as the dashboard, and every command prints JSON, so Claude Code, Cursor or a CI script can drive it. eesel mcp token also exposes the workspace as an MCP server. That is the practical difference from a decision model: the model gives your code a probability, while the CLI gives your code an AI agent that acts on it.

You can try eesel free with 100 credits, no card. Connect your helpdesk, point it at a week of tickets, and compare its routing to what your own decision pipeline would do.