Microsoft-Decision-1.1 vs Gemini Decision 1 for C# Developers: Two Fast Decision Models, One Program

microsoft-decision-1-1-vs-gemini-decision-1-csharp

In October I wrote about Microsoft-Decision-1: a model that doesn’t write anything. You give it some input and a closed set of questions, and it hands back probabilities your code can act on. Since then, Microsoft’s Decision-1.1 became generally available on November 17, 2026, and Google has shipped the same idea as the Gemini Decisions API.

The two are built on the same pattern, which makes them easy to compare. This post puts them side by side from C#: what each one takes, what each one costs, and a small .NET 11 program that sends the same questions to both, so you can read the latency, the probabilities and the token counts yourself. No Python required. Both services are plain HTTP, so HttpClient is enough.

The idea in a minute

Both services work the same way. You send some input and one or more questions. Each question is one of three types:

  • Yes or no (noul): is this invoice missing a purchase order number?
  • Choose one (choice): which team should get this ticket?
  • Rate it (score): how severe is this, on an ordered scale?

The answer is a probability, a chosen label with a probability for every option, or a position on your scale. There is no written rationale. Your code decides what to do with the numbers: route, gate, rank or escalate. Neither service bills output tokens, because there are none.

If a model has to write the answer, use a chat model. If your code needs a branch, these are the cheaper, faster tool. OpenAI has its own version on GPT-6 Luna, which I cover in a separate post and in Chapter 6 of my free ebook. This post sticks to Microsoft and Google.

Side by side

Microsoft-Decision-1.1 Gemini Decision 1
Status Generally available since November 17, 2026 gemini-decision-1 on the Gemini Developer API, v1beta
Inputs Text and images Text, images, PDF documents, audio and video
Endpoint {resource}/providers/microsoft/v1/systemone POST https://generativelanguage.googleapis.com/v1beta/decisions
Sign-in Microsoft Entra ID, or an API key in the api-key header An API key in the x-goog-api-key header
Question types noul, choice, score noul, choice, score
Yes/no criteria true and false true_description and false_description
Extra in the answer Probabilities. A confidence value also came back on choice and score answers in my run, though the Learn page doesn’t document it Probabilities, plus a confidence value on every answer
Limits Not stated on the Microsoft Learn page 1 to 1,000 questions per request, 262,144-token context
Price (input) $0.042 per 1M tokens, Global Standard, output not billed $0.10 per 1M tokens, output not billed, free tier in AI Studio
Where it runs Foundry deployments: Global Standard or Data Zone Standard Gemini Developer API. The page doesn’t say where data is processed

A few notes on that table:

  • Inputs are the big difference. On Microsoft’s side, the Learn page documents images, and a third-party test found PNG and JPEG accepted, while PDF, audio and video returned HTTP 400. Google’s page lists documents, audio and video as input types, so “does this PDF invoice have a PO number?” or “does this call include consent?” is one request.
  • Prices come from different places. The $0.042 figure is from OpenRouter and the Classmethod test, and Microsoft’s announcement says 1.1 costs the same as 1.0 without giving a number. Google’s $0.10 and its free tier come from its announcement. Check both pricing pages. Google also says a file shared across several questions is billed once per request.
  • Speed claims are vendor claims. Google says 150 to 250 ms end to end. Microsoft says 1.1 is “more than twice as fast” as 1.0, with no number. The one independent test I found measured a median of about a second from Japan to a US East resource for Microsoft, network included, and saw no clear speed gain over 1.0. Run both from your own machine.
  • Quality scores are close. Microsoft reports 68 for 1.1 on Artificial Analysis’s Decision Index v2.1, and Artificial Analysis lists Gemini Decision 1 at 66. The 68 is Microsoft’s own figure. A two-point gap on someone else’s tasks tells you little about yours.
  • Google’s preview limits: the page lists no context caching or batch mode for the Decisions API, repeated input counts in full each time, and safety blocks come back as HTTP 400.

The .NET setup

You need the .NET 11 SDK. The code also builds on .NET 10 if you set net10.0 as the target framework and use the 10.0 versions of the two configuration packages. For Microsoft, deploy Microsoft-Decision-1.1 from the Foundry catalog. The request’s model field is your deployment name, not the model name. The program signs in with Entra ID through DefaultAzureCredential, so run az login and give your account the right role on the resource. To use an API key instead, set AZURE_AI_API_KEY as a user secret and skip az login. For Google, create a key in AI Studio. Put checkout-error.png and invoice.pdf from the sample repo next to Program.cs. RUNS (default 5) sets how many times each question set is sent to each service.

One program, two services

The full project is on GitHub: Decision-1-1-vs-Gemini-Decision-1-CSharp-Sample. The program defines each question once, in a neutral form, and each client maps it to its own JSON. It sends three cases to both services:

  1. A text ticket. A choice, a score and a yes/no, the same questions as my first post.
  2. A screenshot. A checkout page with a declined-card error, plus a yes/no and a choice.
  3. A PDF invoice. Two yes/no questions. Gemini takes it. For Microsoft the program prints “not supported”, because the documented input is images.

A few choices in there are deliberate:

  • The questions are identical. Only the request JSON differs: Microsoft puts text in state and images in assets (referenced as image:<name>), and Gemini takes a list of input blocks.
  • The services alternate. Each round calls Microsoft, then Gemini, so both see the same network conditions. The program reports the median over RUNS rounds, not one call.
  • Latency includes the network. That’s what your users feel, but it also means the numbers depend on where you run this and where your Foundry resource is.
  • Cost is input tokens times price. The prices are constants at the top of each client, so update them when the pricing pages change. Microsoft’s Learn page says the response includes token usage but doesn’t name the fields, so the program looks for the first numeric input or prompt field and prints n/a if it can’t find one.

Output

What my run showed

This is one machine, one Foundry resource and five rounds per case, so read it as a data point, not a ruling.

  • They agreed. Both services picked engineering for the ticket and payment_declined for the screenshot. The severity scores were close (2.91 and 2.77 on a scale of 0 to 3), and both said the customer had written before.
  • Microsoft answered with more certainty. Most of its probabilities were 1.00, and Gemini’s were 0.95 to 0.98. Neither is wrong, but if you threshold on a probability, answers pinned at 1.00 leave less room in the middle, so check where your own mistakes land.
  • Both returned a confidence value. Gemini returns one on every answer. Microsoft’s Learn page doesn’t document it, but it came back on the choice and score answers in my run, and not on the yes/no ones.
  • Microsoft was faster and used fewer tokens. The median latency was 135 ms against 337 ms for the text ticket, and 257 ms against 763 ms for the screenshot. Input tokens were 166 against 292 for the text and 365 against 1,268 for the screenshot, so a screenshot cost about $0.000015 against $0.000127, roughly eight times less. These times include the network, and Google’s 150 to 250 ms claim isn’t what I saw from my machine.
  • Only Gemini read the PDF. It answered both invoice questions at 0.96 in 877 ms, and both answers are right: the invoice shows a PO number and a total over 5,000. Microsoft’s service doesn’t take PDFs, so the program skipped that case.

How I’d read your results

Don’t start with the latency. Start with these, in this order:

  1. Do they agree? If both services give the same label on your cases, the choice is about price and inputs. If they disagree, you need a labeled set to say who is right.
  2. How spread are the probabilities? A service that answers 0.99 on everything gives your abstain threshold nothing to work with. Look at how often the top probability lands in the middle.
  3. What do the confidence values mean on your data? Gemini returns one on every answer, and Microsoft’s service returned one on the choice and score answers in my run. It’s a separate number from the probabilities, so check it against your labels before you threshold on it.
  4. What’s the median latency from where your code runs? Include the network, and run enough rounds that one slow call doesn’t decide it.
  5. What does it cost per 1,000 documents? Tokens times price, with your real documents. Images and PDFs cost more tokens than text.

If you already threshold on a probability, such as “send to a person below 0.70” in my first post, re-tune it for each service. The distribution of probabilities isn’t the same across models, and it changed between Decision-1 and 1.1.

Which one would I use?

  • You’re on Azure and your inputs are text and images: Microsoft-Decision-1.1. You get Entra ID, a choice of Global or Data Zone deployment, and the same sign-in and deployment controls as the rest of your Foundry resources.
  • You need PDFs, audio or video, or a lot of questions in one request: Gemini Decision 1. It’s the only one of the two that lists those inputs, and it takes up to 1,000 questions per request.
  • Cost per image document is what matters: measure both with your own documents. The token counts differ more than the prices do.
  • Data location matters: read both vendors’ terms first. Sending documents to the Gemini Developer API is a different arrangement from sending them to your own Foundry resource, and Google’s page doesn’t say where the data is processed.

Two cautions apply to both. Neither returns a rationale, so don’t use one as the only decision-maker for credit, hiring, housing, health or legal outcomes. Both vendors advise human review for consequential decisions. And Gemini’s v1beta is a beta surface, so pin your code and test it on each change.

Wrapping up

Microsoft and Google shipped the same bet in the same season: for the small, repeated judgments in an application, a model that scores is faster and cheaper than one that writes. The difference is in the inputs and the platform. Microsoft-Decision-1.1 is the one that sits inside your Azure resource, and Gemini Decision 1 is the one that reads your PDFs and audio. Run your own cases through both, read the confident mistakes, and let the numbers decide.

Resources

Building AI features in C#? I write about practical, no-hype prompt engineering and Azure AI patterns for .NET developers. Check out Prompt Engineering for .NET Developers, free and with no Python required. You can also subscribe for more posts.

Taswar Bhatti Avatar

Written by