Customize

MicrosoftOfficialCreated by Microsoft

Skill
Workflow
Cloud and DevOps
MIT
No issues found

From the author

Interactive guided deployment flow for Azure OpenAI models with full customization control. Step-by-step selection of model version, SKU (GlobalStandard/Standard/ProvisionedManaged), capacity, RAI policy (content filter), and advanced options (dynamic quota, priority processing, spillover). USE FOR: custom deployment, customize model deployment, choose version, select SKU, set capacity, configure content filter, RAI policy, deployment options, detailed deployment, advanced deployment, PTU deployment, provisioned throughput. DO NOT USE FOR: quick deployment to optimal region (use preset).

— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured, step-by-step process for deploying Azure OpenAI models. It enables users to specify exact model versions, select from various SKUs, set capacity, configure content filtering through RAI policies, and manage advanced deployment options like dynamic quota and spillover. The workflow includes automated checks for authentication, project verification, and capacity availability, with built-in cross-region fallback logic if capacity is unavailable in the primary region.

What it does

Guides users through a 14-phase deployment process for Azure OpenAI models.
Allows selection of specific model versions and deployment SKUs.
Configures capacity, RAI policies, and advanced features like priority processing.
Performs automated validation of project resources and subscription quotas.
Supports cross-region fallback if capacity is not available in the target region.
Generates and validates deployment names for consistency.

When to use it

When you require precise control over your Azure OpenAI model deployment configuration.
When you need to select specific model versions rather than the latest default.
When configuring advanced deployment features like PTU, spillover, or dynamic quota.
When you need to manually select or verify available SKUs and capacity.

Advantages

Provides granular control over every aspect of the deployment process.
Reduces configuration errors through automated validation and live data queries.
Simplifies complex tasks like cross-region capacity searching.
Ensures deployment parameters meet specific project requirements.

Usage examples

“Deploy gpt-4o with ProvisionedManaged SKU and 100 PTU capacity.”: The agent initiates the guided flow, prompts for the project resource ID, validates the SKU and capacity requirements, and executes the deployment.
“I need to customize my model deployment with specific RAI policies.”: The agent guides you through the RAI policy selection phase, presenting available content filter options for your chosen model.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/microsoft/customize/download
Unzip it into the cross-client skills folder of your project:
```
mkdir -p .agents/skills && unzip customize.zip -d .agents/skills
```

Documentation by Microsoft

Customize Model Deployment

Interactive guided workflow for deploying Azure OpenAI models with full customization control over version, SKU, capacity, content filtering, and advanced options.

Quick Reference

Property	Description
Flow	Interactive step-by-step guided deployment
Customization	Version, SKU, Capacity, RAI Policy, Advanced Options
SKU Support	GlobalStandard, Standard, ProvisionedManaged, DataZoneStandard
Best For	Precise control over deployment configuration
Authentication	Azure CLI (`az login`)
Tools	Azure CLI, MCP tools (optional)

When to Use This Skill

Use this skill when you need precise control over deployment configuration:

✅ Choose specific model version (not just latest)
✅ Select deployment SKU (GlobalStandard vs Standard vs PTU)
✅ Set exact capacity within available range
✅ Configure content filtering (RAI policy selection)
✅ Enable advanced features (dynamic quota, priority processing, spillover)
✅ PTU deployments (Provisioned Throughput Units)

Alternative: Use preset for quick deployment to the best available region with automatic configuration.

Comparison: customize vs preset

Feature	customize	preset
Focus	Full customization control	Optimal region selection
Version Selection	User chooses from available	Uses latest automatically
SKU Selection	User chooses (GlobalStandard/Standard/PTU)	GlobalStandard only
Capacity	User specifies exact value	Auto-calculated (50% of available)
RAI Policy	User selects from options	Default policy only
Region	Current region first, falls back to all regions if no capacity	Checks capacity across all regions upfront
Use Case	Precise deployment requirements	Quick deployment to best region

Prerequisites

Azure subscription with Cognitive Services Contributor or Owner role
Microsoft Foundry project resource ID (format: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}/projects/{project})
Azure CLI installed and authenticated (az login)
Optional: Set PROJECT_RESOURCE_ID environment variable

Workflow Overview

Complete Flow (14 Phases)

1. Verify Authentication
2. Get Project Resource ID
3. Verify Project Exists
4. Get Model Name (if not provided)
5. List Model Versions → User Selects
6. List SKUs for Version → User Selects
7. Get Capacity Range → User Configures
   7b. If no capacity: Cross-Region Fallback → Query all regions → User selects region/project
8. List RAI Policies → User Selects
9. Configure Advanced Options (if applicable)
10. Configure Version Upgrade Policy
11. Generate Deployment Name
12. Review Configuration
13. Execute Deployment & Monitor

Fast Path (Defaults)

If user accepts all defaults (latest version, GlobalStandard SKU, recommended capacity, default RAI policy, standard upgrade policy), deployment completes in ~5 interactions.

Phase Summaries

⚠️ MUST READ: Before executing any phase, load references/customize-workflow.md for the full scripts and implementation details. The summaries below describe what each phase does — the reference file contains the how (CLI commands, quota patterns, capacity formulas, cross-region fallback logic).

Phase	Action	Key Details
1. Verify Auth	Check `az account show`; prompt `az login` if needed	Verify correct subscription is active
2. Get Project ID	Read `PROJECT_RESOURCE_ID` env var or prompt user	ARM resource ID format required
3. Verify Project	Parse resource ID, call `az cognitiveservices account show`	Extracts subscription, RG, account, project, region
4. Get Model	List models via `az cognitiveservices account list-models`	User selects from available or enters custom name
5. Select Version	Query versions for chosen model	Recommend latest; user picks from list
6. Select SKU	Query model catalog + subscription quota, show only deployable SKUs	⚠️ Never hardcode SKU lists — always query live data
7. Configure Capacity	Query capacity API, validate min/max/step, user enters value	Cross-region fallback if no capacity in current region
8. Select RAI Policy	Present content filter options	Default: `Microsoft.DefaultV2`
9. Advanced Options	Dynamic quota (GlobalStandard), priority processing (PTU), spillover	SKU-dependent availability
10. Upgrade Policy	Choose: OnceNewDefaultVersionAvailable / OnceCurrentVersionExpired / NoAutoUpgrade	Default: auto-upgrade on new default
11. Deployment Name	Auto-generate unique name, allow custom override	Validates format: `^[\w.-]{2,64}$`
12. Review	Display full config summary, confirm before proceeding	User approves or cancels
13. Deploy & Monitor	`az cognitiveservices account deployment create`, poll status	Timeout after 5 min; show endpoint + portal link

Error Handling

Common Issues and Resolutions

Error	Cause	Resolution
Model not found	Invalid model name	List available models with `az cognitiveservices account list-models`
Version not available	Version not supported for SKU	Select different version or SKU
Insufficient quota	Capacity > available quota	Skill auto-searches all regions; fails only if no region has quota
SKU not supported	SKU not available in region	Cross-region fallback searches other regions automatically
Capacity out of range	Invalid capacity value	PREVENTED: Skill validates min/max/step at input (Phase 7)
Deployment name exists	Name conflict	Auto-incremented name generation
Authentication failed	Not logged in	Run `az login`
Permission denied	Insufficient permissions	Assign Cognitive Services Contributor role
Capacity query fails	API/permissions/network error	DEPLOYMENT BLOCKED: Will not proceed without valid quota data

Troubleshooting Commands

# Check deployment status
az cognitiveservices account deployment show --name <account> --resource-group <rg> --deployment-name <name>

# List all deployments
az cognitiveservices account deployment list --name <account> --resource-group <rg> -o table

# Check quota usage
az cognitiveservices usage list --name <account> --resource-group <rg>

# Delete failed deployment
az cognitiveservices account deployment delete --name <account> --resource-group <rg> --deployment-name <name>

Selection Guides & Advanced Topics

For SKU comparison tables, PTU sizing formulas, and advanced option details, load references/customize-guides.md.

SKU selection: GlobalStandard (production/HA) → Standard (dev/test) → ProvisionedManaged (high-volume/guaranteed throughput) → DataZoneStandard (data residency).

Capacity: TPM-based SKUs range from 1K (dev) to 100K+ (large production). PTU-based use formula: (Input TPM × 0.001) + (Output TPM × 0.002) + (Requests/min × 0.1).

Advanced options: Dynamic quota (GlobalStandard only), priority processing (PTU only, extra cost), spillover (overflow to backup deployment).

preset - Quick deployment to best region with automatic configuration
microsoft-foundry - Parent skill for all Microsoft Foundry operations
quota — For quota viewing, increase requests, and troubleshooting quota errors, defer to this skill instead of duplicating guidance
rbac - Manage permissions and access control

Notes

Set PROJECT_RESOURCE_ID environment variable to skip prompt
Not all SKUs available in all regions; capacity varies by subscription/region/model
Custom RAI policies can be configured in Azure Portal
Automatic version upgrades occur during maintenance windows
Use Azure Monitor and Application Insights for production deployments

Files

ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
EXAMPLES.md4.3 KiB
LICENSELicence file added by AutoGineer1.1 KiB
SKILL.md8.8 KiB
references/customize-guides.md3.4 KiB
references/customize-workflow.md13.1 KiB

references/customize-workflow.md

Customize Workflow — Detailed Phase Instructions

Reference for: models/deploy-model/customize/SKILL.md

Phase 1: Verify Authentication

az account show --query "{Subscription:name, User:user.name}" -o table

If not logged in: az login

Set subscription if needed:

az account list --query "[].[name,id,state]" -o table
az account set --subscription <subscription-id>

Phase 2: Get Project Resource ID

Check PROJECT_RESOURCE_ID env var. If not set, prompt user.

Format: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}/projects/{project}

Phase 3: Parse and Verify Project

Parse ARM resource ID to extract components:

$SUBSCRIPTION_ID = ($PROJECT_RESOURCE_ID -split '/')[2]
$RESOURCE_GROUP = ($PROJECT_RESOURCE_ID -split '/')[4]
$ACCOUNT_NAME = ($PROJECT_RESOURCE_ID -split '/')[8]
$PROJECT_NAME = ($PROJECT_RESOURCE_ID -split '/')[10]

Verify project exists and get region:

az account set --subscription $SUBSCRIPTION_ID
az cognitiveservices account show \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --query location -o tsv

Phase 4: Get Model Name

List available models if not provided:

az cognitiveservices account list-models \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --query "[].name" -o json

Present sorted unique list. Allow custom model name entry.

Detect model format:

# Get model format (e.g., OpenAI, Anthropic, Meta-Llama, Mistral, Cohere)
MODEL_FORMAT=$(az cognitiveservices account list-models \
  --name "$ACCOUNT_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --query "[?name=='$MODEL_NAME'].format" -o tsv | head -1)

MODEL_FORMAT=${MODEL_FORMAT:-"OpenAI"}
echo "Model format: $MODEL_FORMAT"

💡 Model format determines the deployment path:
OpenAI — Standard CLI, TPM-based capacity, RAI policies, version upgrade policies
Anthropic — REST API with modelProviderData, capacity=1, no RAI, no version upgrade
All other formats (Meta-Llama, Mistral, Cohere, etc.) — Standard CLI, capacity=1 (MaaS), no RAI, no version upgrade

Phase 5: List and Select Model Version

az cognitiveservices account list-models \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --query "[?name=='$MODEL_NAME'].version" -o json

Recommend latest version (first in list). Default to "latest" if no versions found.

Phase 6: List and Select SKU

⚠️ Warning: Never hardcode SKU lists — always query live data.

Step A — Query model-supported SKUs:

az cognitiveservices model list \
  --location $PROJECT_REGION \
  --subscription $SUBSCRIPTION_ID -o json

Filter: model.name == $MODEL_NAME && model.version == $MODEL_VERSION, extract model.skus[].name.

Step B — Check subscription quota per SKU:

az cognitiveservices usage list \
  --location $PROJECT_REGION \
  --subscription $SUBSCRIPTION_ID -o json

Quota key pattern: OpenAI.<SKU>.<model-name>. Calculate available = limit - currentValue.

Step C — Present only deployable SKUs (available > 0). If no SKUs have quota, direct user to the quota skill.

Phase 7: Configure Capacity

⚠️ Non-OpenAI models (MaaS): If MODEL_FORMAT != "OpenAI", capacity is always 1 (pay-per-token billing). Skip capacity configuration and set DEPLOY_CAPACITY=1. Proceed to Phase 7c (Anthropic) or Phase 8.

For OpenAI models only — query capacity via REST API:

# Current region capacity
az rest --method GET --url \
  "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/$PROJECT_REGION/modelCapacities?api-version=2024-10-01&modelFormat=$MODEL_FORMAT&modelName=$MODEL_NAME&modelVersion=$MODEL_VERSION"

Filter result for properties.skuName == $SELECTED_SKU. Read properties.availableCapacity.

Capacity defaults by SKU (OpenAI only):

SKU	Unit	Min	Max	Step	Default
ProvisionedManaged	PTU	50	1000	50	100
Others (TPM-based)	TPM	1000	min(available, 300000)	1000	min(10000, available/2)

Validate user input: must be >= min, <= max, multiple of step. On invalid input, explain constraints.

Phase 7b: Cross-Region Fallback

If no capacity in current region, query ALL regions:

az rest --method GET --url \
  "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/modelCapacities?api-version=2024-10-01&modelFormat=$MODEL_FORMAT&modelName=$MODEL_NAME&modelVersion=$MODEL_VERSION"

Filter: properties.skuName == $SELECTED_SKU && properties.availableCapacity > 0. Sort descending by capacity.

Present available regions. After user selects region, find existing projects there:

az cognitiveservices account list \
  --query "[?kind=='AIProject' && location=='$PROJECT_REGION'].{Name:name, ResourceGroup:resourceGroup}" \
  -o json

If projects exist, let user select one and update $ACCOUNT_NAME, $RESOURCE_GROUP. If none, direct to project/create skill.

Re-run capacity configuration with new region's available capacity.

If no region has capacity: fail with guidance to request quota increase, check existing deployments, or try different model/SKU.

Phase 7c: Anthropic Model Provider Data (Anthropic models only)

⚠️ Only execute this phase if MODEL_FORMAT == "Anthropic". For OpenAI and other models, skip to Phase 8.

Anthropic models require modelProviderData in the deployment payload. Collect this before deployment.

Step 1: Prompt user to select industry

Present the following list and ask the user to choose one:

 1. None                    (API value: none)
 2. Biotechnology           (API value: biotechnology)
 3. Consulting              (API value: consulting)
 4. Education               (API value: education)
 5. Finance                 (API value: finance)
 6. Food & Beverage         (API value: food_and_beverage)
 7. Government              (API value: government)
 8. Healthcare              (API value: healthcare)
 9. Insurance               (API value: insurance)
10. Law                     (API value: law)
11. Manufacturing           (API value: manufacturing)
12. Media                   (API value: media)
13. Nonprofit               (API value: nonprofit)
14. Technology              (API value: technology)
15. Telecommunications      (API value: telecommunications)
16. Sport & Recreation      (API value: sport_and_recreation)
17. Real Estate             (API value: real_estate)
18. Retail                  (API value: retail)
19. Other                   (API value: other)

⚠️ Do NOT pick a default industry or hardcode a value. Always ask the user. This is required by Anthropic's terms of service. The industry list is static — there is no REST API that provides it.

Store selection as SELECTED_INDUSTRY (use the API value, e.g., technology).

Step 2: Fetch tenant info (country code and organization name)

TENANT_INFO=$(az rest --method GET \
  --url "https://management.azure.com/tenants?api-version=2024-11-01" \
  --query "value[0].{countryCode:countryCode, displayName:displayName}" -o json)

COUNTRY_CODE=$(echo "$TENANT_INFO" | jq -r '.countryCode')
ORG_NAME=$(echo "$TENANT_INFO" | jq -r '.displayName')

PowerShell version:

$tenantInfo = az rest --method GET `
  --url "https://management.azure.com/tenants?api-version=2024-11-01" `
  --query "value[0].{countryCode:countryCode, displayName:displayName}" -o json | ConvertFrom-Json

$countryCode = $tenantInfo.countryCode
$orgName = $tenantInfo.displayName

Store COUNTRY_CODE and ORG_NAME for use in Phase 13.

Phase 8: Select RAI Policy (Content Filter)

⚠️ Note: RAI policies only apply to OpenAI models. Skip this phase if MODEL_FORMAT != "OpenAI" (Anthropic, Meta-Llama, Mistral, Cohere, etc. do not use RAI policies).

Present options:

Microsoft.DefaultV2 — Balanced filtering (recommended). Filters hate, violence, sexual, self-harm.
Microsoft.Prompt-Shield — Enhanced prompt injection/jailbreak protection.
Custom policies — Organization-specific (configured in Azure Portal).

Default: Microsoft.DefaultV2.

Phase 9: Configure Advanced Options

Options are SKU-dependent:

A. Dynamic Quota (GlobalStandard only)

Auto-scales beyond base allocation when capacity available
Default: enabled

B. Priority Processing (ProvisionedManaged only)

Prioritizes requests during high load; additional charges apply
Default: disabled

C. Spillover (any SKU)

Redirects requests to backup deployment at capacity
Requires existing deployment; list with:

az cognitiveservices account deployment list \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --query "[].name" -o json

Default: disabled

Phase 10: Configure Version Upgrade Policy

⚠️ Note: Version upgrade policies only apply to OpenAI models. Skip this phase if MODEL_FORMAT != "OpenAI".

Policy	Description
`OnceNewDefaultVersionAvailable`	Auto-upgrade to new default (Recommended)
`OnceCurrentVersionExpired`	Upgrade only when current expires
`NoAutoUpgrade`	Manual upgrade only

Default: OnceNewDefaultVersionAvailable.

Phase 11: Generate Deployment Name

List existing deployments to avoid conflicts:

az cognitiveservices account deployment list \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --query "[].name" -o json

Auto-generate: use model name as base, append -2, -3 etc. if taken. Allow custom override. Validate: ^[\w.-]{2,64}$.

Phase 12: Review Configuration

Display summary of all selections for user confirmation before proceeding:

Model, version, deployment name
SKU, capacity (with unit), region
RAI policy, version upgrade policy
Advanced options (dynamic quota, priority, spillover)
Account, resource group, project

User confirms or cancels.

Phase 13: Execute Deployment

💡 MODEL_FORMAT was already detected in Phase 4. Use the stored value here.

Standard CLI deployment (non-Anthropic models):

Create deployment:

az cognitiveservices account deployment create \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --deployment-name $DEPLOYMENT_NAME \
  --model-name $MODEL_NAME \
  --model-version $MODEL_VERSION \
  --model-format "$MODEL_FORMAT" \
  --sku-name $SELECTED_SKU \
  --sku-capacity $DEPLOY_CAPACITY

💡 Note: For non-OpenAI MaaS models, $DEPLOY_CAPACITY is 1 (set in Phase 7).

Anthropic model deployment (requires modelProviderData):

The Azure CLI does not support --model-provider-data. Use the ARM REST API directly.

⚠️ Industry, country code, and organization name should have been collected in Phase 7c.

echo "Creating Anthropic model deployment via REST API..."

az rest --method PUT \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.CognitiveServices/accounts/$ACCOUNT_NAME/deployments/$DEPLOYMENT_NAME?api-version=2024-10-01" \
  --body "{
    \"sku\": {
      \"name\": \"$SELECTED_SKU\",
      \"capacity\": 1
    },
    \"properties\": {
      \"model\": {
        \"format\": \"Anthropic\",
        \"name\": \"$MODEL_NAME\",
        \"version\": \"$MODEL_VERSION\"
      },
      \"modelProviderData\": {
        \"industry\": \"$SELECTED_INDUSTRY\",
        \"countryCode\": \"$COUNTRY_CODE\",
        \"organizationName\": \"$ORG_NAME\"
      }
    }
  }"

PowerShell version:

Write-Host "Creating Anthropic model deployment via REST API..."

$body = @{
    sku = @{
        name = $SELECTED_SKU
        capacity = 1
    }
    properties = @{
        model = @{
            format = "Anthropic"
            name = $MODEL_NAME
            version = $MODEL_VERSION
        }
        modelProviderData = @{
            industry = $SELECTED_INDUSTRY
            countryCode = $countryCode
            organizationName = $orgName
        }
    }
} | ConvertTo-Json -Depth 5

az rest --method PUT `
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.CognitiveServices/accounts/$ACCOUNT_NAME/deployments/${DEPLOYMENT_NAME}?api-version=2024-10-01" `
  --body $body

💡 Note: Anthropic models use capacity: 1 (MaaS billing model), not TPM-based capacity. RAI policy is not applicable for Anthropic models.

Monitor deployment status:

az cognitiveservices account deployment show \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --deployment-name $DEPLOYMENT_NAME \
  --query "properties.provisioningState" -o tsv

Poll until Succeeded or Failed. Timeout after 5 minutes.

Get endpoint:

az cognitiveservices account show \
  --name $ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --query "properties.endpoint" -o tsv

On success, display deployment name, model, version, SKU, capacity, region, RAI policy, rate limits, endpoint, and Microsoft Foundry portal link.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs a command-line tool

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Microsoft

Publisher

Microsoft (Official)

Source

microsoft/skills · .github/plugins/azure-skills/skills/microsoft-foundry/models/deploy-model/customize · commit 0696600

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from .github/plugins/azure-skills/LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

Also distributed in

microsoft/azure-skills

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download customize.zip