As AI applications evolve from simple chat experiences into complex, agentic systems, developers are rethinking how they use models. Rather than relying on a single large language model for every task, they're increasingly building applications that combine specialized models, each optimized for a specific purpose. Some generate content, others reason through complex problems, and a growing category focuses on something equally important: making decisions.
Consider an AI agent that needs to determine which tool to call, whether a customer request requires escalation, or what action to take next. These decisions happen repeatedly throughout an application, but they don't always require the generative capabilities of a large language model. Using one for every decision can introduce unnecessary latency and cost, particularly at scale.
Decision models address this challenge by helping applications select the right outcome from a defined set of choices, quickly and efficiently. As developers build more sophisticated multi-model systems, specialized decision intelligence is becoming an increasingly valuable part of the architecture.
Today, we're introducing Microsoft-Decision-1.1, now generally available in Microsoft Foundry, bringing improved decision quality, faster inference, and multimodal capabilities to developers building intelligent applications.
What's new in Microsoft-Decision-1.1?
Microsoft-Decision-1.1 builds on the original model with improvements to accuracy, calibration, and latency. In Microsoft's evaluation across 102 benchmarks containing more than 385,000 questions held out from training, Microsoft-Decision-1.1 achieved an average accuracy of 78.8%, leading in seven of nine capability categories.
Microsoft-Decision-1.1 is based on Gemma 4 26B A4, with specialized training for decision-making and a custom inference engine. Microsoft-Decision-1.1 is more than twice as fast as Microsoft-Decision-1. Improved calibration also helps developers use confidence signals to set application-specific thresholds thresholds for when to act automatically and when to request additional review.
The release also introduces multimodal capabilities, allowing developers to incorporate images into decision instructions. This opens new possibilities for applications that need to classify visual content, route requests based on screenshots, or make decisions using both text and image inputs.
With general availability in Microsoft Foundry, developers can integrate Microsoft-Decision-1.1 into production workflows. The model is also available through OpenRouter and Vercel, expanding access across development environments.
Why use a decision model?
The value of a decision model becomes clear when you consider how often applications need to choose an action rather than generate an answer.
Imagine a customer support agent receiving the request, "I was charged twice for my subscription." Before generating a response, the application needs to determine whether to route the request to billing, technical support, or account management. Microsoft-Decision-1.1 can evaluate the request and select the appropriate category, allowing the application to move directly to the next step.
The same approach applies to tool selection in AI agents, incident prioritization, document classification, and workflow verification. For example, an agent could use a decision model to determine whether it has enough information to proceed, needs to retrieve additional context, or should escalate to a human.
These decisions may seem small, but an agentic workflow can make hundreds of them. Using a specialized model for these operations helps developers reduce unnecessary generation, improve responsiveness, and control inference costs.
This approach also creates opportunities to separate decision-making from generation. A decision model determines what should happen next, while a generative model handles tasks that require reasoning, explanation, or content creation.
Microsoft-Decision-1.1 is also available as a judge in Foundry Evaluations to assess performance, quality, and safety. This gives developers another way to apply decision models within Foundry, alongside using them for classification, routing, and workflow control in their own applications.
Pricing designed for high-volume decision workloads
Decision-making is often a high-frequency operation. As applications scale, even small differences in inference cost can have a significant impact.
Microsoft-Decision-1.1 offers consumption-based pricing, with output tokens included at no additional charge.
|
Deployment type |
Input price per 1M tokens |
|
Global Standard |
$0.042 |
|
US Data Zone |
$0.046 |
|
EU Data Zone |
$0.050 |
|
APAC Data Zone |
$0.050 |
Get started with Microsoft-Decision-1.1
Start with a decision your application needs to make. The following quickstarts show how to ask questions about images, select exactly one outcome, and identify every applicable option.
Connect to your Foundry deployment
Deploy Microsoft-Decision-1.1 from the Foundry model catalog. You need Python 3.10 or later, the Azure CLI, and an identity with inference access to the resource, for example through the Cognitive Services User role. Requests incur applicable usage charges.
python -m pip install azure-identity
az login
export AZURE_ENDPOINT="https://<your-resource>.services.ai.azure.com"
export DEPLOYMENT_NAME="decision-1.1"
AZURE_ENDPOINT is your Foundry resource root, without a project path or API suffix. DEPLOYMENT_NAME must match your deployment name, not necessarily the underlying model name; replace decision-1.1 if yours differs.
Save this connection code as md1_client.py. Both quickstarts below import its keyword-only ask helper.
import json
import os
import urllib.error
import urllib.request
from azure.identity import DefaultAzureCredential
AZURE_ENDPOINT = os.environ["AZURE_ENDPOINT"].rstrip("/")
DEPLOYMENT_NAME = os.environ["DEPLOYMENT_NAME"]
TOKEN_SCOPE = "https://cognitiveservices.azure.com/.default"
credential = DefaultAzureCredential()
def ask(*, state, questions, assets=None):
payload = {
"model": DEPLOYMENT_NAME,
"state": state,
"questions": questions,
}
if assets is not None:
payload["assets"] = assets
access_token = credential.get_token(TOKEN_SCOPE).token
request = urllib.request.Request(
f"{AZURE_ENDPOINT}/providers/microsoft/v1/systemone",
data=json.dumps(payload).encode("utf-8"),
headers={
"Authorization": f"Bearer {access_token}",
"Content-Type": "application/json",
"Accept": "application/json",
},
method="POST",
)
try:
with urllib.request.urlopen(request, timeout=120) as response:
result = json.load(response)
except urllib.error.HTTPError as error:
raise RuntimeError(f"Foundry returned HTTP {error.code}") from error
answers = result["answers"]
if not isinstance(answers, dict) or set(answers) != set(questions):
raise ValueError("Foundry returned missing or unexpected answers")
return answers
DefaultAzureCredential obtains and refreshes Entra tokens; locally it can use your Azure CLI login. No API key is required. Keep credentials server-side and out of source code and logs. If a call returns HTTP 401 or 403, check your credential, tenant, and resource permissions. Transport and authentication failures raise errors rather than becoming negative decisions. See the Foundry deployment and API guide for access details.
Turn an image into a structured decision
Assume two images are provided beside your script, each 448 by 448 pixels:
|
File |
Contents |
|
red-circle.png |
A red circle on a white background |
|
blue-square.png |
A blue square on a white background |
Save the following as image_demo.py. Declare an image in assets, then reference its exact key in state, question instructions, or answer-option descriptions. Brackets in names such as [photo] are a convention, not a requirement.
Ask three questions about one shared image
import base64
import json
from pathlib import Path
from md1_client import ask
def image_asset(filename):
return {
"type": "image",
"format": "png",
"data_base64": base64.b64encode(
Path(filename).read_bytes()
).decode("ascii"),
}
red = image_asset("red-circle.png")
blue = image_asset("blue-square.png")
answers = ask(
state="Inspect the prominent colored shape in this image: [photo]",
questions={
"red_shape": {
"type": "noul",
"instructions": "Is the prominent colored shape red?",
},
"shape": {
"type": "choice",
"instructions": "What is the prominent colored shape?",
"criteria": {
"circle": "A circular shape with a curved boundary.",
"square": "A square with four straight sides.",
"other": "Neither a circle nor a square, or not discernible.",
},
},
"blue_square": {
"type": "noul",
"instructions": "Does the image contain a blue square?",
},
},
assets={"[photo]": red},
)
print(json.dumps(answers, indent=2))
This sends one image and three questions in one HTTP request. Expect a high red_shape.noul, shape.choice equal to "circle", and a low blue_square.noul. Noul returns the probability of yes; Choice returns one selected option and its option distribution. Actual probabilities vary.
State can also be structured JSON-compatible data: for example, replace the state string with {"attachments": [{"image": "[photo]"}]}. References in string values are resolved recursively. Questions share the state but cannot see one another's answers.
Put an image in the instructions
Append these remaining image blocks to image_demo.py. A question-specific image does not have to appear in shared state:
answers = ask(
state="Evaluate the image supplied with this question.",
questions={
"blue_square": {
"type": "noul",
"instructions": "Does this image contain a blue square? [local]",
}
},
assets={"[local]": blue},
)
print(json.dumps(answers, indent=2))
Expect a high yes probability. Instructions are a string; selectable options belong in criteria.
Put images in the answer options
answers = ask(
state="Target image: [target]",
questions={
"match": {
"type": "choice",
"instructions": (
"Which reference matches the target's colored shape and color? "
"Ignore filenames; compare the visual content."
),
"criteria": {
"reference_a": "The target matches this reference: [reference_a]",
"reference_b": "The target matches this reference: [reference_b]",
"neither": "Neither reference matches the target.",
},
}
},
assets={"[target]": red, "[reference_a]": red, "[reference_b]": blue},
)
print(json.dumps(answers, indent=2))
Expect match.choice equal to "reference_a". The target and first reference deliberately use the same supplied image.
Compare two images
answers = ask(
state="Image A: [a]. Image B: [b].",
questions={
"same_shape": {
"type": "noul",
"instructions": (
"Do A and B show the same geometric shape, ignoring color?"
),
},
"same_color": {
"type": "noul",
"instructions": (
"Are the prominent colored shapes in A and B the same color?"
),
},
},
assets={"[a]": red, "[b]": blue},
)
print(json.dumps(answers, indent=2))
Expect low yes probabilities for both comparisons. Replace blue with red to try a matching pair. Use code rather than a model for exact file equality.
Run all four image requests with python image_demo.py. Use PNG or JPEG bytes, not URLs or data URIs; for JPEG, change format to "jpeg". Both image dimensions must be 280–1,568 pixels. Declare only assets referenced in that request. References belong in supported string values, not object keys. Keep prompts within the eight-rendered-image-occurrences-per-question limit; question-side references can render twice. These simple fixtures demonstrate the API, not general visual accuracy.
Single-select or multi-select: choose the question design
Use one Choice question containing all options when exactly one outcome should be selected. Use one Noul question per option, batched into one request, when zero, one, or several options can apply. This is a question-design pattern, not a new selection type in 1.1.
Save the next two blocks together as selection_demo.py. Both functions accept keyword-only state, options, and instructions. State can be text or structured JSON-compatible data and is passed through unchanged. Only the example options and instructions are ticket-specific.
Single-select: one Choice question
import json from md1_client import ask OPTIONS = { "billing": "Charges, invoices, refunds, or subscription payments.", "technical": "Software errors, crashes, outages, or integration failures.", "account": "Sign-in, password, or account-access problems.", } SINGLE_OPTIONS = { **OPTIONS, "other": "No listed team applies, or no problem is identifiable.", } SINGLE_INSTRUCTIONS = ( "Which team should handle the primary problem in this ticket? " "Select exactly one. If several problems appear, choose the team " "for the explicitly stated main problem; otherwise use the first " "problem mentioned. Use other if none of the teams applies." ) def single_select(*, state, options, instructions): answers = ask( state=state, questions={ "selection": { "type": "choice", "instructions": instructions, "criteria": options, } }, ) answer = answers["selection"] label = answer["choice"] return { "selected": label, "selected_probability": answer["probabilities"][label], "probabilities": answer["probabilities"], } print("Single-select:", json.dumps( single_select( state="My main problem is that I was charged twice.", options=SINGLE_OPTIONS, instructions=SINGLE_INSTRUCTIONS, ), indent=2, ))
Expect "billing". The other option avoids forcing an unrelated request into a real team. Use the returned selected label's probability, not an assumed confidence field, when applying a review policy.
Multi-select: one Noul question per option
MULTI_INSTRUCTIONS = (
"Does this ticket contain a problem in the following category? "
"{description} "
"Evaluate this category even if another problem is more prominent."
)
# Demonstration policy only; calibrate against labeled data before deployment.
SELECT_AT = 0.80
REJECT_AT = 0.20
def multi_select(*, state, options, instructions):
questions = {
name: {
"type": "noul",
"instructions": instructions.format(description=description),
"criteria": {
"true": f"The state supports this option: {description}",
"false": (
"The state does not support this option under the instructions."
),
},
}
for name, description in options.items()
}
answers = ask(state=state, questions=questions)
probabilities = {name: answers[name]["noul"] for name in options}
return {
"selected": [
name for name, p in probabilities.items() if p >= SELECT_AT
],
"not_selected": [
name for name, p in probabilities.items() if p <= REJECT_AT
],
"needs_review": [
name for name, p in probabilities.items()
if REJECT_AT < p < SELECT_AT
],
"probabilities": probabilities,
}
print("Multi-select:", json.dumps(
multi_select(
state={
"ticket": (
"I was charged twice, and the mobile app crashes when I open it. "
"Signing in works normally."
)
},
options=OPTIONS,
instructions=MULTI_INSTRUCTIONS,
),
indent=2,
))
Run both selection examples with python selection_demo.py. Each function makes one HTTP request. Multi-select expands the {description} instruction template once per option; it sends three Noul questions, not one Choice question attempting to return several labels.
For this ticket, the intended selections are billing and technical. Actual selections depend on the returned probabilities and your thresholds. Unlike a Choice distribution, Noul values do not need to sum to one: each refers to a different yes-or-no question. Do not normalize them or multiply them into a joint confidence score.
The example preserves uncertainty in needs_review rather than treating every unselected option as a confident no. The 0.80 and 0.20 thresholds illustrate an application policy, not recommended defaults. Evaluate zero, one, multiple, and all-label cases, as well as precision, recall, and review rates on representative labeled data. The same Choice/Noul question-design pattern applies to image inputs using the assets mechanism shown above.
Together, these patterns show how to connect evidence to an application action: supply text or images, define the decisions you need, and use the structured results to route work or request review. Start with a bounded task and measure decision quality, latency, and cost on your own workload.
Build smarter AI applications with Microsoft Foundry
As AI applications become more autonomous, making the right decisions between model calls will be just as important as generating high-quality responses.
Microsoft-Decision-1.1 gives developers a specialized model for these workloads, combining improved decision quality, efficient inference, and multimodal capabilities. By pairing decision models with generative models and capabilities such as model router, developers can build applications that use the right intelligence for each task.
Explore Microsoft-Decision-1.1 in Microsoft Foundry and see how specialized decision intelligence can help you build faster, more cost-efficient AI applications.
For deployment guidance and technical details, visit the Microsoft-Decision documentation on Microsoft Learn.