# OpenAI Decisions API lands in Foundry: Luna vs Decision-1

The OpenAI Decisions API went GA in Microsoft Foundry on 22 October 2026: GPT-6 Luna behind a dedicated endpoint at $0.10 per million input tokens, no output charge, images and 400 questions per call, available in Sweden Central. Azure teams now have two hosted decision models, and once a stable rubric is cached the Luna option lands within a few hundred dollars a month of Microsoft-Decision-1 at twenty million calls.

- Published: 2026-10-25 · Category: Azure & Cloud · Tags: OpenAI Decisions API, GPT-6 Luna, Microsoft-Decision-1, Microsoft Foundry, Azure OpenAI, Decision Models, AI Agents, EU Data Zone, Prompt Caching, LLM Cost
- Author: Technspire AB, Stockholm (https://technspire.com)
- Canonical: https://technspire.com/en/blog/openai-decisions-api-foundry-ga-luna-vs-microsoft-decision-1

On 22 October 2026 the OpenAI Decisions API went generally available in Microsoft Foundry, on the same day OpenAI took it out of beta on its own platform. It runs on GPT-6 Luna through a dedicated `/openai/v1/decisions` endpoint on an Azure OpenAI resource, bills $0.10 per million input tokens and nothing for output, and accepts text, images and up to 400 questions in one call. Two weeks ago we wrote that [Azure-only teams had one decision model, Microsoft-Decision-1](/en/blog/microsoft-decision-1-foundry-0-042-eu-data-zone-decision-models), and that OpenAI's version "does not exist for you yet". That sentence is now wrong, and the choice it leaves behind is a real one: a 9B-parameter Microsoft model at $0.042 that only reads text, or OpenAI's cheap-tier frontier model at $0.10 that also reads images and reasons harder. Both run inside the EU Data Zone from Sweden Central. Here is how to pick.

## What shipped on 22 October

The Foundry version is the OpenAI API with an Azure hostname. You create a `gpt-6-luna` deployment, point the standard OpenAI Python or JavaScript SDK at `https://.openai.azure.com/openai/v1/`, and call `decisions.create` with your deployment name in the model field. Microsoft's how-to requires the OpenAI Python library 3.26.0 or later and the JavaScript library 7.30.0 or later. Authentication is an API key or a Microsoft Entra ID token, the same two options as every other Azure OpenAI endpoint.

A request has three parts. The `input` is the evidence: a string, or user messages whose content can mix `input_text` and `input_image` parts. The `questions` array holds what you want decided, each with a type, instructions and a unique name. The response returns an `answers` array in the same order, plus token usage.

| Question type | Ask it when | What comes back |
| --- | --- | --- |
| `predicate` | A condition is true or false: does this photo show damage, does this message ask for a refund | `probability` from 0 to 1 |
| `choice` | One option from an unordered set: which team, which category | `choice`, a probability per option, and a separate `confidence` |
| `score` | A position on an ordered scale: severity, quality against a rubric | `score` as the probability-weighted average of level indices, plus per-level probabilities and `confidence` |

Microsoft's own example routes a support complaint. Note the `other` fallback and the short option descriptions: both are billed as input tokens on every call.

```
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/decisions \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6-luna",
    "input": "I was charged twice for my order.",
    "questions": [{
      "type": "choice",
      "name": "department",
      "instructions": "Which department should handle this complaint?",
      "choices": [
        {"value": "billing",   "description": "Payments and refunds."},
        {"value": "technical", "description": "Product problems."},
        {"value": "shipping",  "description": "Delivery and tracking."},
        {"value": "other",     "description": "All other requests."}
      ]
    }]
  }'

// response (abridged)
{
  "answers": [{
    "type": "choice", "name": "department", "choice": "billing",
    "probabilities": [
      {"value": "billing", "probability": 0.95},
      {"value": "technical", "probability": 0.02},
      {"value": "shipping", "probability": 0.01},
      {"value": "other", "probability": 0.02}
    ],
    "confidence": 0.93
  }],
  "usage": {"input_tokens": 162, "output_tokens": 0, "total_tokens": 162}
}
```

Limits worth writing down before you design around them. Each request takes up to 400 questions, doubled from the 200 in OpenAI's beta. Images can be PNG, JPG, WebP or GIF, up to 128 per request and 32 MB combined, passed as base64 data URLs or public HTTPS URLs that the service can fetch without your network or cookies. Any single question can come back as a `refusal` while the others still receive answers, so your code has to branch on `answer.type` before reading a probability. A refusal is not a low probability. Treat it as a separate route, usually to a human.

Regions follow the model: the endpoint "is rolling out to regions where gpt-6-luna is available", with East US 2 explicitly excluded for now. Microsoft's region table lists Luna in Sweden Central under both Global Standard and Data Zone Standard, which is the row Swedish buyers care about.

## The price sheet, and one line that is new

The Tech Community post publishes a four-column price table for the Decisions API on Azure. Azure's public pricing page still shows placeholders for GPT-6 Luna and says the prices are "in processing", so the blog post is the only Microsoft price source today.

| Option, per million tokens | Input | Cached input | Cache write | Output | Images | EU processing |
| --- | --- | --- | --- | --- | --- | --- |
| Decisions API, GPT-6 Luna, Foundry (GA 22 Oct) | $0.10 | $0.01 | $0.125 (30-minute) | None | Yes, up to 128 | Luna has an EU Data Zone; no separate Decisions row published |
| Microsoft-Decision-1, Foundry (GA 9 Oct) | $0.042 | Not listed | Not listed | None | No, text only | EU Data Zone at the same price |
| Decisions API, OpenAI platform (GA 22 Oct) | $0.10 | Standard cache-read rate | Standard cache-write rate | None | Yes | EEA plus Switzerland regional processing, ZDR for eligible customers |
| GPT-6 Luna via Responses API, Foundry, for reference | $0.10 Global, $0.12 EU zone | $0.01 / $0.012 | Per GPT-5.6+ caching rules | $0.50 / $0.60 | Yes | EU Data Zone at a 20% premium |

Three things in that table deserve a second look.

**The cache write line is new to Azure OpenAI.** Models before the GPT-5.6 family never charged to write to the prompt cache. Microsoft's caching documentation now says that "on GPT-5.6 models and later model families, cache writes can incur charges in addition to discounted cache reads", and the Decisions GA post is the first place we have seen a figure: $0.125 per million tokens for a 30-minute cache write, against $0.01 to read. The arithmetic only pays if each written prefix is read more than about 14 times before it expires. For a routing rubric hit thousands of times an hour that is trivially true. For a rubric you change every deploy it is not.

**There is no Data Zone row for the Decisions API.** Luna's chat pricing carries a 20% EU Data Zone premium. The Decisions post lists one price with no deployment-type column. Until the pricing page catches up, assume your EU Data Zone deployment may meter at $0.12 and check the first invoice.

**Decision-1 is still 2.4 times cheaper on raw input.** It was 2.4 times cheaper on 10 October too, when the comparison was academic because the OpenAI option was off Azure. Now the gap is between two meters on the same subscription, and caching narrows it.

## Cost math: the same two workloads, rerun

We used two workloads in the Decision-1 post. Rerunning them with the Decisions API on Azure, list prices, EU Data Zone where a price exists and the published Global price where it does not.

**Workload 1: support ticket routing.** 500,000 tickets a month at roughly 600 input tokens each, counting the ticket, instructions and option descriptions. That is 300 million input tokens. Prompt caching needs a 1,024-token identical prefix, so these calls fall below the floor and nothing is cached.

- Microsoft-Decision-1, EU Data Zone: 300M × $0.042 = about $12.60 a month.
- Decisions API on Luna: 300M × $0.10 = $30, or $36 if the EU zone premium applies.
- Luna via Responses API, EU zone, minimal reasoning, 10-token JSON answer: about $39, and an order of magnitude more if reasoning is on.

Nobody chooses on $17 a month. At this scale the decision is made by whether you need images, how hard the judgement is, and which API your team already speaks.

**Workload 2: step-gating an agent fleet.** 20 million policy checks a month, each carrying about 2,000 tokens of tool call, context and rubric. That is 40 billion input tokens. Assume 1,200 of those tokens are a stable rubric prefix that caches.

| Option | Uncached input | Cached input | Output | Monthly |
| --- | --- | --- | --- | --- |
| Microsoft-Decision-1, EU Data Zone | 40B × $0.042 = $1,680 | No cache tier listed | $0 | $1,680 |
| Decisions API on Luna, no cache hits | 40B × $0.10 = $4,000 | $0 | $0 | $4,000 |
| Decisions API on Luna, rubric cached | 16B × $0.10 = $1,600 | 24B × $0.01 = $240 | $0 | about $1,840 plus cache writes |
| Luna via Responses API, EU zone, 20 output tokens | $4,800 | Not assumed | $240 | $5,040 |

With the rubric cached, the Decisions API lands within $160 a month of Decision-1 on 20 million calls, and it brings image input and a reasoning-grade model for that money. The cache write cost is small if the rubric is stable: one write per 30 minutes per prefix is a rounding error at this volume. Two cautions. The `usage` block exposes `cached_tokens` and `cache_write_tokens`, so measure the real hit rate on your traffic before you bank the saving; whether your stable text lands in the cacheable prefix depends on how you order input and questions. And at 20 million calls a month, the 20% EU Data Zone premium, if it applies to the Decisions meter, adds about $370.

## Decision guide: Luna or Decision-1

Both models answer the same kinds of question and both return calibrated probabilities you can threshold. The differences are in input, model class and API shape.

| Dimension | Decisions API on GPT-6 Luna | Microsoft-Decision-1 |
| --- | --- | --- |
| Input | Text and images, up to 128 images | Text only, 32K context |
| Questions per call | 400 | Multiple named questions; no published cap |
| Base model | GPT-6 Luna, OpenAI | Qwen3.5-9B, post-trained by Microsoft, rebase to MAI or OpenAI announced |
| Endpoint | `/openai/v1/decisions`, OpenAI SDKs work unchanged | `/providers/microsoft/v1/systemone`, custom request shape |
| Auth | API key or Entra ID | Entra ID token |
| Latency claim | 10x faster than Luna through the Responses API (OpenAI) | P50 35x lower than GPT-6 Sol (Microsoft) |
| Caching | $0.01 read, $0.125 write | None listed |
| Portability | Same API on OpenAI's platform | Foundry only today |

**Pick the Decisions API on Luna when** the evidence includes images (damage photos, document scans, screenshots from a browser agent), when the judgement is subtle enough that a 9B model's accuracy worries you, when you want one SDK for generation and decisions, or when your model register cannot carry a Qwen-derived base. Also pick it if portability to OpenAI's own platform matters for a non-Azure part of the estate; the request shape is identical.

**Pick Decision-1 when** the input is text, the volume is very high, calls are short enough that caching cannot help, and the lowest meter wins. Ticket triage, relevance scoring of retrieval results and rubric grading of other models' prose all fit. Pin version 1, because Microsoft has said the base will change.

**Run both when** you are building an agent gate. Put Decision-1 in front of every tool call as the cheap first pass, and send anything between your two thresholds to the Decisions API with the screenshot attached. That is the pattern the vendors' own latency claims point at, and it is the one that makes the Luna bill small.

Neither is a sandbox. A probability that a tool call looks safe is a signal for your policy engine, not a boundary around the agent. We made that case in [A classifier is not a sandbox](/en/blog/coding-agent-sandboxing-auto-mode-break), and the [six-agent refund incident](/en/blog/six-agents-one-350-refund-your-azure-agent-guardrails) is what happens when the signal is the only control.

## Five checks before the first production call

- **1. Confirm the deployment SKU and the meter.** Create the `gpt-6-luna` deployment as DataZoneStandard in Sweden Central, make a hundred Decisions calls, and read the cost analysis view two days later. That is the only way to learn whether the EU premium applies to this endpoint.
- **2. Turn off key auth.** The endpoint accepts API keys. Set `disableLocalAuth` on the resource, give the calling identity the Cognitive Services OpenAI User role, and apply the Azure Policy that denies local auth across the subscription. One less secret to rotate.
- **3. Calibrate on your own labels.** Run a thousand historically labelled items through, bucket predicted probability in tenths, and plot it against observed accuracy. Set the human-review threshold from that plot. Do the same for Decision-1 if you run both, because the two curves will not match.
- **4. Measure the cache.** Log `cached_tokens` and `cache_write_tokens` from the usage block for a day. If writes approach reads, your rubric is changing too often or your prefix is below 1,024 tokens, and the cheap tier in the table above is not the tier you are paying.
- **5. Handle refusals as a route.** Write the branch for `answer.type === "refusal"` before you write the happy path. Send it to a queue a person reads, and count it. A rising refusal rate is usually a prompt problem, not a model problem.

## The Swedish and EU angle

**Residency is solved on both sides, pricing is not.** Luna sits in Sweden Central under Data Zone Standard, so prompts and responses for a Decisions call stay inside the Azure EU Data Boundary. That removes the objection we raised against Claude Haiku 5.5 in [the Haiku price post](/en/blog/claude-haiku-5-5-foundry-0-10-tier-100k-cliff-vs-gpt-6-luna), where the cheap tier had no EU zone at all. What the launch material does not say is what the EU zone costs for this endpoint. Budget for $0.12 until the pricing page publishes.

**Provenance is simpler with Luna.** Several Swedish public-sector and defence-adjacent buyers now ask vendors to document the origin of model weights. Decision-1 requires a paragraph: Microsoft-hosted, Microsoft-post-trained, Qwen3.5-9B base under Apache 2.0, rebase pending. Luna requires a line: OpenAI model, Microsoft-hosted, Microsoft terms. If that paragraph has been blocking a procurement, the Decisions API is the first way to get a hosted decision model past it on Azure.

**The AI Act still looks at the decision, not the endpoint.** Routing a ticket is minimal-risk under either model. Deciding who gets a loan interview or which applicant advances is an Annex III high-risk use, and the stand-alone Annex III obligations apply from 2 December 2027 after the Digital Omnibus. GDPR Article 22 on solely automated decisions with significant effects has no deferral. The calibrated probability is the cheapest honest implementation of meaningful human involvement: document the threshold below which a person decides, log the probability next to every outcome, and you have something an auditor can test.

**OpenAI's own EU option is not the same thing.** OpenAI's platform offers EEA-plus-Switzerland regional processing and zero data retention for eligible customers. That is a different data processor and a different contract from your Microsoft enterprise agreement. For a Swedish organisation already on Azure, the Foundry endpoint is the one that inherits the existing DPA, the existing Entra tenant and the existing Defender for Cloud posture. The request shape being identical means you can keep the OpenAI platform as a tested fallback without a second codebase.

## Conclusion

The Decisions API arriving in Foundry closes the gap we flagged two weeks ago and gives Azure teams two hosted decision models with EU processing. Decision-1 remains the cheapest text-only meter in the catalog. The Decisions API on Luna costs more per raw token, reads images, runs a frontier-tier model and, once a stable rubric is cached, lands within a few hundred dollars a month of Decision-1 at twenty million calls. Deploy Luna as Data Zone Standard in Sweden Central, disable key auth, calibrate on your own labels, and watch the first invoice for the EU premium that the launch post does not mention.

## Sources

- [Microsoft Tech Community: Azure OpenAI Decisions API, now generally available in Microsoft Foundry (23 October 2026)](https://techcommunity.microsoft.com/blog/azure-ai-foundry-blog/azure-openai-decisions-api-now-generally-available-in-microsoft-foundry/4567265)
- [Microsoft Learn: Use the Azure OpenAI Decisions API](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/decisions)
- [Microsoft Learn: Prompt caching with Azure OpenAI in Microsoft Foundry Models](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/prompt-caching)
- [Microsoft Learn: Region availability for Foundry Models sold by Azure](https://learn.microsoft.com/en-us/azure/foundry/foundry-models/concepts/models-sold-directly-by-azure-region-availability)
- [OpenAI API changelog: Decisions API generally available (22 October 2026)](https://developers.openai.com/api/docs/changelog)
- [OpenAI: Decisions API guide](https://developers.openai.com/api/docs/guides/decisions)
- [Technspire: Microsoft-Decision-1 in Foundry: $0.042 and the EU zone (10 October 2026)](/en/blog/microsoft-decision-1-foundry-0-042-eu-data-zone-decision-models)

---

Technspire AB builds AI agents, Azure OpenAI solutions, and production web platforms for Swedish and EU enterprises. Book a call: https://calendly.com/technspire · hello@technspire.com · More articles: https://technspire.com/en/blog · Site overview for agents: https://technspire.com/llms.txt