Instant access to models in Microsoft Foundry (preview)

Learn about instant access in Microsoft Foundry, which let you call any supported model by name without creating a deployment first.

Instant access to models lets you call any supported model by name — no deployment required. Create a Foundry project, start coding, and use any available model immediately.

Prerequisites

• An Azure subscription. Create one for free.
• Sign in to Microsoft Foundry. Make sure the New Foundry toggle is on. These steps refer to Foundry (new).

• A Foundry project in West US 3 (the only supported region for instant access during preview). If you need to create a project, see Create a project.
• The Foundry User role on the project or account.

The Foundry RBAC roles were recently renamed. Foundry User, Foundry Owner, Foundry Account Owner, and Foundry Project Manager were previously named Azure AI User, Azure AI Owner, Azure AI Account Owner, and Azure AI Project Manager. You might still see the previous names in some places while the rename rolls out. The role IDs and core permissions are unchanged by the rename.

Start using models instantly

With instant access, the workflow is simple — use a supported instant model name in your code. No deployment needed. The same API, SDK, and client you already use for deployments works with instant access models. No second SDK, no separate client, no configuration changes.

Support for instant access continues to expand over time. The exact set changes frequently. See Supported models for ways to see the full list.

Python

For the model parameter, use the instant access model name, such as "gpt-5-mini", instead of a deployed model name.

import os
from dotenv import load_dotenv
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

load_dotenv()

print(f"Using PROJECT_ENDPOINT: {os.environ['PROJECT_ENDPOINT']}")
print(f"Using MODEL_DEPLOYMENT_NAME: {os.environ['MODEL_DEPLOYMENT_NAME']}")

project_client = AIProjectClient(
    endpoint=os.environ["PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

openai_client = project_client.get_openai_client()

response = openai_client.responses.create(
    model=os.environ["MODEL_DEPLOYMENT_NAME"],
    input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")

C#

For the model parameter, use the instant access model name, such as "gpt-5-mini", instead of a deployed model name.

using Azure.AI.Projects;
using Azure.AI.Projects.OpenAI;
using Azure.Identity;
using OpenAI.Responses;

#pragma warning disable OPENAI001

string projectEndpoint = Environment.GetEnvironmentVariable("PROJECT_ENDPOINT")
?? throw new InvalidOperationException("Missing environment variable 'PROJECT_ENDPOINT'");
string modelDeploymentName = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME")
?? throw new InvalidOperationException("Missing environment variable 'MODEL_DEPLOYMENT_NAME'");

AIProjectClient projectClient = new(new Uri(projectEndpoint), new AzureCliCredential());

ProjectResponsesClient responseClient = projectClient.OpenAI.GetProjectResponsesClientForModel(modelDeploymentName);
ResponseResult response = await responseClient.CreateResponseAsync("What is the size of France in square miles?");

Console.WriteLine(response.GetOutputText());

TypeScript

For the model parameter, use the instant access model name, such as "gpt-5-mini", instead of a deployed model name.

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import "dotenv/config";

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const deploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "<model deployment name>";

async function main(): Promise<void> {
    const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
    const openAIClient = project.getOpenAIClient();
    const response = await openAIClient.responses.create({
        model: deploymentName,
        input: "What is the size of France in square miles?",
    });
    console.log(`Response output: ${response.output_text}`);
}

main().catch(console.error);

Java

For the model parameter, use the instant access model name, such as "gpt-5-mini", instead of a deployed model name.

package com.azure.ai.agents;

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

public class CreateResponse {
    public static void main(String[] args) {
        // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
        String ProjectEndpoint = "your_project_endpoint";

        // Create responses client to call Foundry API
        ResponsesClient responsesClient = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(ProjectEndpoint)
                .buildResponsesClient();

        // Run a responses API call
        ResponseCreateParams responseRequest = new ResponseCreateParams.Builder()
                .input("What is the size of France in square miles?")
                .model("gpt-5-mini")
                .build();
        Response response = responsesClient.getResponseService().create(responseRequest);
        System.out.println(response.output());
    }
}

REST API

For the model parameter, use the instant access model name, such as "gpt-5-mini", instead of a deployed model name.

Also replace YOUR-FOUNDRY-RESOURCE-NAME with your values:

curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/openai/responses?api-version=2025-11-15-preview \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
-d '{
        "model": "gpt-4.1-mini",
        "input": "What is the size of France in square miles?"
}'

Foundry portal

1. On the Home page of your project, select Test in playground.
2. Use the Model dropdown in the playground to switch among deployed and instant access models.

Playground for instant access models

To reach the playground for instant access models, use one of these paths:

1. From Home, select Test in playground.
2. From Home, select Explore models to go to the model catalog. Or, select Discover > Models. Either path opens the catalog.
3. From the model catalog, select an instant access model to view its details.
4. From an instant access model details page, select Open playground.
5. From a playground, use the Model dropdown to switch to other instant access or deployed models.

Why instant access matters

• Switch models by changing one string — use any instant model name in the model= line, without creating or deleting deployments.
• Same API and SDK — the same calls work for both instant access and deployments.
• Works with your dev tools — instant access integrates with Foundry CLI, VS Code, and CI/CD pipelines the same way deployments do.

Deployments aren’t going away. They remain the right choice when you need reserved throughput, custom content filters, data residency, or advanced enterprise configurations. Instant access simplify the getting-started experience so that deployments become something you level up to, not a gate you must pass before you can use a model.

Supported models

New models support instant access by default when they’re released. The product team considers support for additional models based on customer demand. The list grows over time, and examples of models you might see include:

• chat-gpt-latest
• gpt-5.6-sol
• gpt-5.5
• gpt-5-mini
• gpt-5.3-codex

To see all models that support instant access:

1. Open a project in West US 3 in the new Foundry experience,
2. Select Discover in the upper-right navigation, then Models in the left pane.
3. In the model catalog, select Instant under Development options to view the available instant access models.

You can also list instant access models programmatically:

SUBSCRIPTION_ID="<your-subscription-id>"
LOCATION="westus3"

az rest --method get \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/$LOCATION/models?api-version=2025-06-01" \
  --output json \
| jq -r '(.value // .models // .)[]
  | select((.model.capabilities.instant // "false" | tostring | ascii_downcase) == "true")
  | .model.name' \
| sort -u

During the preview, instant access models are available in projects in West US 3 only.

Some instant access models might appear in the list even if your subscription has no quota for them. For more information, see Quotas and limits for Foundry Models.

When to use instant access vs. deployments

Scenario	Recommended approach
Getting started, prototyping, or experimentation	Instant access
Using the latest model immediately after release	Instant access
Need reserved capacity or predictable throughput	Deployment
Require provisioned throughput (PTU)	Deployment
Need data residency in a specific region	Deployment
Custom content filtering policies per model	Deployment
Custom guardrails per model	Deployment
Endpoint-specific configuration (for example, version locks per endpoint)	Deployment
Fine-grained quota partitioning across teams	Deployment
Fine-tuned models	Deployment

Instant access and deployments can coexist in the same project. You can start with instant access model and create a deployment later as your requirements evolve.

Model versions

By default, instant access uses the latest evergreen version of a model. To pin to a specific version, append the version date to the model name as a hyphenated suffix:

What you pass as model	Behavior
model-name	Routes to the latest version
model-name-2025-04-01	Routes to that specific version

Version pinning is opt-in. If your application requires stability, include the version suffix. Otherwise, you always get the latest version automatically.

How quota is consumed

Instant access draws from a per-model global quota pool assigned to your subscription. This quota is separate from the regional quota used by standard deployments.

• You don’t allocate or partition global quota — it’s shared automatically across all instant model usage in your subscription.
• Global Standard deployments reserve a portion of your global quota. Instant access models use whatever capacity remains.
• Other deployment types (Regional Standard, Provisioned) use separate regional quota and don’t affect your instant model capacity.
• If instant model requests are throttled, you can request a quota increase or create a deployment with reserved capacity.

For more details on how global and regional quotas interact, see Manage and increase quotas.

Enterprise controls

Capability	How it works
Block specific models or providers	Azure Policy definitions apply to instant access the same way they apply to deployments
Pin to a model version	Append the version suffix to the model name (see Model versions)
Disable instant access entirely	Administrators can turn off instant access at the subscription level through Azure Policy

To remove instant access from an account, configure the settings through Bicep or ARM REST.

REST API

Update your account with:

PATCH https://management.azure.com/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}?api-version=2026-01-15-preview
Authorization: Bearer {arm_token}
Content-Type: application/json

Use this request body to effectively shut off instant model access:

{
  "properties": {
    "instant": {
      "raiPolicyName": "Microsoft.DefaultV2",
      "modelAllowList": []
    }
  }
}

Bicep

Update your existing account resource with an instant block:

resource account 'Microsoft.CognitiveServices/accounts@2026-01-15-preview' = {
  name: accountName
  location: location
  kind: 'AIServices'
  sku: {
    name: 'S0'
  }
  // Keep your existing account properties and add instant settings.
  properties: {
    instant: {
      raiPolicyName: 'Microsoft.DefaultV2'
      modelAllowList: []
    }
  }
}

All instant access models use default guardrails and content filters. However, you can’t configure custom guardrails or Responsible AI (RAI) policies on a per-model basis for instant access. You can set a default RAI policy at the account level through the API, but that policy applies uniformly to all instant access models. If you need different content filtering policies for individual models, use a deployment.

Deployment name collisions

New deployments can’t use a name that matches an existing model name. If you have an existing deployment whose name collides with a model name, the deployment takes precedence and instant model access for that model name is unavailable in that project.

Limitations during preview

• Available in West US 3 only.
• Fine-tuned models aren’t supported. To use a fine-tuned model, create a deployment.
• Guardrails, custom RAI policies, and content filters aren’t configurable for instant access.
• Only the models listed in Supported models are eligible.

Related content

• Deployment overview for Microsoft Foundry Models
• Deployment types for Microsoft Foundry Models
• Manage quotas for Foundry resources
• Microsoft Foundry quickstart